diff --git a/engine/api/src/main/java/io/deephaven/engine/table/ColumnSource.java b/engine/api/src/main/java/io/deephaven/engine/table/ColumnSource.java
index 23fafe1248e..c70c2fe65a0 100644
--- a/engine/api/src/main/java/io/deephaven/engine/table/ColumnSource.java
+++ b/engine/api/src/main/java/io/deephaven/engine/table/ColumnSource.java
@@ -126,18 +126,33 @@ default T createTupleFromValues(@NotNull final Object... values) {
     }
 
     @Override
-    default <ELEMENT_TYPE> void exportElement(final T tuple, final int elementIndex,
+    @FinalDefault
+    default int tupleLength() {
+        return 1;
+    }
+
+    @Override
+    @FinalDefault
+    default <ELEMENT_TYPE> void exportElement(@NotNull final T tuple, final int elementIndex,
             @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationIndexKey) {
         // noinspection unchecked
         writableSource.set(destinationIndexKey, (ELEMENT_TYPE) tuple);
     }
 
     @Override
-    default Object exportElement(T tuple, int elementIndex) {
+    @FinalDefault
+    default Object exportElement(@NotNull final T tuple, final int elementIndex) {
         Require.eqZero(elementIndex, "elementIndex");
         return tuple;
     }
 
+    @Override
+    @FinalDefault
+    default void exportAllTo(final Object @NotNull [] dest, @NotNull final T tuple) {
+        Require.geqZero(dest.length, "dest.length");
+        dest[0] = tuple;
+    }
+
     @Override
     ColumnSource<T> getPrevSource();
 
diff --git a/engine/api/src/main/java/io/deephaven/engine/table/TupleExporter.java b/engine/api/src/main/java/io/deephaven/engine/table/TupleExporter.java
index 3244c0e2d2c..b16aafb955b 100644
--- a/engine/api/src/main/java/io/deephaven/engine/table/TupleExporter.java
+++ b/engine/api/src/main/java/io/deephaven/engine/table/TupleExporter.java
@@ -7,10 +7,17 @@
 
 /**
  * Interface for classes that know how to export the elements of a given tuple type. Currently, supports element-wise
- * export to a {@link WritableColumnSource} without unnecessary boxing.
+ * export to a {@link WritableColumnSource} without unnecessary boxing, and possibly-boxing export as {code Object}.
  */
 public interface TupleExporter<TUPLE_TYPE> {
 
+    /**
+     * Get the number of elements in tuples supported by this TupleExporter.
+     *
+     * @return The number of elements in tuples supported by this TupleExporter
+     */
+    int tupleLength();
+
     /**
      * Export a single element from the tuple, identified by its element index, to the destination row key of the
      * supplied writable source.
@@ -26,39 +33,131 @@ public interface TupleExporter<TUPLE_TYPE> {
      * @param writableSource The destination
      * @param destinationIndexKey The destination row key
      */
-    <ELEMENT_TYPE> void exportElement(TUPLE_TYPE tuple, int elementIndex,
-            @NotNull WritableColumnSource<ELEMENT_TYPE> writableSource, long destinationIndexKey);
+    <ELEMENT_TYPE> void exportElement(
+            @NotNull TUPLE_TYPE tuple,
+            int elementIndex,
+            @NotNull WritableColumnSource<ELEMENT_TYPE> writableSource,
+            long destinationIndexKey);
 
     /**
-     * Export a single element from the tuple, identified by its element index, to an Object
-     * 
+     * Export a single element (identified by {@code elementIndex}) from the tuple, boxing as necessary.
      * <p>
      * For the empty tuple, this is unsupported.
-     * <p>
-     * For singles, this will copy the sole element, possibly in boxed form.
-     * <p>
-     * For doubles and longer, this will copy the specified element without any unnecessary boxing.
      *
      * @param tuple The tuple to export an element from
      * @param elementIndex The element index to export
+     * @return The exported element, boxed when necessary
      */
-    Object exportElement(TUPLE_TYPE tuple, int elementIndex);
+    Object exportElement(@NotNull TUPLE_TYPE tuple, int elementIndex);
 
     /**
-     * Export a single element from the tuple, identified by its element index, to an Object. If the tuple has been
-     * internally reinterpreted, return the reinterpreted value.
-     *
+     * Fill an {@code Object[]} with all elements from the tuple, boxing as necessary.
      * <p>
      * For the empty tuple, this is unsupported.
+     *
+     * @param dest The destination {@code Object[]}
+     * @param tuple The tuple to export from
+     */
+    default void exportAllTo(final Object @NotNull [] dest, @NotNull final TUPLE_TYPE tuple) {
+        final int length = tupleLength();
+        for (int ei = 0; ei < length; ++ei) {
+            dest[ei] = exportElement(tuple, ei);
+        }
+    }
+
+    /**
+     * Fill an {@code Object[]} with all elements from the tuple, boxing as necessary, mapping the tuple elements to the
+     * destination array using the provided {@code int[]} {code map}. This map contains the destination index for each
+     * tuple element in order.
      * <p>
-     * For singles, this will copy the sole element, possibly in boxed form.
+     * Providing {@code map = new int{1, 2, 0}} means that the 0th element of the tuple will be written in
+     * {@code dest[1]}, the 1st element of the tuple will be written in {@code dest[2]}, and the 2nd element of the
+     * tuple will be written in {@code dest[0]}.
      * <p>
-     * For doubles and longer, this will copy the specified element without any unnecessary boxing.
+     * For the empty tuple, this is unsupported.
+     *
+     * @param dest The destination {@code Object[]}
+     * @param tuple The tuple to export from
+     * @param map Instructions where to write each tuple element in {@code dest}
+     */
+    default void exportAllTo(
+            final Object @NotNull [] dest,
+            @NotNull final TUPLE_TYPE tuple,
+            final int @NotNull [] map) {
+        final int length = tupleLength();
+        for (int ei = 0; ei < length; ++ei) {
+            dest[map[ei]] = exportElement(tuple, ei);
+        }
+    }
+
+    /**
+     * Export a single element (identified by {@code elementIndex}) from the tuple, boxing as necessary. If the tuple
+     * has been internally reinterpreted, return the reinterpreted value.
+     * <p>
+     * For the empty tuple, this is unsupported.
      *
      * @param tuple The tuple to export an element from
      * @param elementIndex The element index to export
+     * @return The exported element, reinterpreted if internally reinterpreted, boxed when necessary
      */
-    default Object exportElementReinterpreted(TUPLE_TYPE tuple, int elementIndex) {
+    default Object exportElementReinterpreted(@NotNull final TUPLE_TYPE tuple, final int elementIndex) {
         return exportElement(tuple, elementIndex);
     }
+
+    /**
+     * Fill an {@code Object[]} with all element from the tuple, boxing as necessary. If the tuple has been internally
+     * reinterpreted, will fill with reinterpreted values.
+     * <p>
+     * For the empty tuple, this is unsupported.
+     *
+     * @param dest The destination {@code Object[]}
+     * @param tuple The tuple to export from
+     */
+    default void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final TUPLE_TYPE tuple) {
+        final int length = tupleLength();
+        for (int ei = 0; ei < length; ++ei) {
+            dest[ei] = exportElementReinterpreted(tuple, ei);
+        }
+    }
+
+    /**
+     * Fill an Object[] with all element from the tuple, boxing as necessary, mapping the tuple elements to the
+     * destination array using the provided int[] map. This map contains the destination index for each tuple element in
+     * order. will fill with reinterpreted values.
+     * <p>
+     * Providing {@code map = new int{1, 2, 0}} means that the 0th element of the tuple will be written in
+     * {@code dest[1]}, the 1st element of the tuple will be written in {@code dest[2]}, and the 2nd element of the
+     * tuple will be written in {@code dest[0]}.
+     * <p>
+     * For the empty tuple, this is unsupported.
+     *
+     * @param dest The destination {@code Object[]}
+     * @param tuple The tuple to export from
+     * @param map Instructions where to write each tuple element in {@code dest}
+     */
+    default void exportAllReinterpretedTo(
+            final Object @NotNull [] dest,
+            @NotNull final TUPLE_TYPE tuple,
+            final int @NotNull [] map) {
+        final int length = tupleLength();
+        for (int ei = 0; ei < length; ++ei) {
+            dest[map[ei]] = exportElementReinterpreted(tuple, ei);
+        }
+    }
+
+    @FunctionalInterface
+    interface ExportElementFunction<TUPLE_TYPE> {
+
+        /**
+         * Export a single element from the tuple, identified by its element index, to an Object. This interface is
+         * intended to be compatible with both {@link TupleExporter#exportElement(Object, int)} and
+         * {@link TupleExporter#exportElementReinterpreted(Object, int)}, and consequently does not specify whether the
+         * result will be reinterpreted.
+         *
+         * @param tuple The tuple to export an element from
+         * @param elementIndex The element index to export
+         * @return The exported element, boxed when necessary
+         */
+        Object exportElement(@NotNull TUPLE_TYPE tuple, int elementIndex);
+    }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/DynamicWhereFilter.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/DynamicWhereFilter.java
index 7e1b2d7f4bf..9c7b466dc99 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/DynamicWhereFilter.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/DynamicWhereFilter.java
@@ -13,24 +13,19 @@
 import io.deephaven.engine.rowset.chunkattributes.OrderedRowKeys;
 import io.deephaven.engine.table.*;
 import io.deephaven.engine.table.impl.*;
-import io.deephaven.engine.table.impl.dataindex.DataIndexUtils;
-import io.deephaven.engine.table.impl.dataindex.DataIndexKeySet;
 import io.deephaven.engine.table.impl.indexer.DataIndexer;
+import io.deephaven.engine.table.impl.select.setinclusion.SetInclusionKernel;
 import io.deephaven.engine.table.impl.sources.ReinterpretUtils;
 import io.deephaven.engine.table.iterators.ChunkedColumnIterator;
 import io.deephaven.engine.updategraph.NotificationQueue;
 import io.deephaven.engine.updategraph.UpdateGraph;
-import io.deephaven.hash.KeyedObjectHashMap;
-import io.deephaven.hash.KeyedObjectKey;
 import io.deephaven.util.SafeCloseable;
 import io.deephaven.util.annotations.ReferentialIntegrity;
-import org.apache.commons.lang3.mutable.MutableInt;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.*;
 import java.util.function.Function;
-import java.util.stream.Collectors;
 
 /**
  * A where filter that extracts a set of inclusion or exclusion keys from a set table.
@@ -41,26 +36,27 @@ public class DynamicWhereFilter extends WhereFilterLivenessArtifactImpl implemen
 
     private static final int CHUNK_SIZE = 1 << 16;
 
-    private final MatchPair[] matchPairs;
+    private final MatchPair[] sourceToSetColumnNamePairs;
     private final boolean inclusion;
 
-    private final DataIndexKeySet liveValues;
-
-    private final QueryTable setTable;
-    private final ChunkSource.WithPrev<Values> setKeySource;
     @SuppressWarnings("FieldCanBeLocal")
     @ReferentialIntegrity
     private final InstrumentedTableUpdateListener setUpdateListener;
 
-    private Object[] liveValuesArray;
+    private final SetInclusionKernel setKernel;
+    private final Class<?> @NotNull [] setKeyTypes;
+
+    private final QueryTable setTable;
+    private List<Object> staticSetLookupKeys;
 
     private ColumnSource<?>[] sourceKeyColumns;
+    private TupleSource<Object> sourceKeySource;
     /**
      * The optimal data index for this filter.
      */
-    @Nullable
-    private DataIndex sourceDataIndex;
-    private int[] indexToSetKeyOffsets;
+    private @Nullable DataIndex sourceDataIndex;
+    private int @Nullable [] tupleToIndexMap;
+    private int @Nullable [] indexToTupleMap;
 
     private RecomputeListener listener;
     private QueryTable resultTable;
@@ -68,33 +64,38 @@ public class DynamicWhereFilter extends WhereFilterLivenessArtifactImpl implemen
     public DynamicWhereFilter(
             @NotNull final QueryTable setTable,
             final boolean inclusion,
-            final MatchPair... setColumnsNames) {
+            final MatchPair... sourceToSetColumnNamePairs) {
         if (setTable.isRefreshing()) {
             updateGraph.checkInitiateSerialTableOperation();
         }
-        this.matchPairs = setColumnsNames;
+        this.sourceToSetColumnNamePairs = sourceToSetColumnNamePairs;
         this.inclusion = inclusion;
 
-        liveValues = DataIndexUtils.makeKeySet(setColumnsNames.length);
-
-        final ColumnSource<?>[] setColumns = Arrays.stream(matchPairs)
-                .map(mp -> setTable.getColumnSource(mp.rightColumn())).toArray(ColumnSource[]::new);
+        // Use reinterpreted column sources for the set table tuple source.
+        final ColumnSource<?>[] setColumns = Arrays.stream(this.sourceToSetColumnNamePairs)
+                .map(mp -> setTable.getColumnSource(mp.rightColumn()))
+                .map(ReinterpretUtils::maybeConvertToPrimitive)
+                .toArray(ColumnSource[]::new);
+        setKeyTypes = Arrays.stream(setColumns).map(ColumnSource::getType).toArray(Class[]::new);
+        final TupleSource<?> setKeySource = TupleSourceFactory.makeTupleSource(setColumns);
+        setKernel = SetInclusionKernel.makeKernel(setKeySource.getChunkType(), inclusion);
+
+        // Fill liveValues and the set kernel with the initial keys from the set table.
+        if (setTable.getRowSet().isNonempty()) {
+            try (final CloseableIterator<?> initialKeysIterator = ChunkedColumnIterator.make(
+                    setKeySource, setTable.getRowSet(), getChunkSize(setTable.getRowSet()))) {
+                initialKeysIterator.forEachRemaining(this::addKeyUnchecked);
+            }
+        }
 
         if (setTable.isRefreshing()) {
-            setKeySource = DataIndexUtils.makeBoxedKeySource(setColumns);
-            if (setTable.getRowSet().isNonempty()) {
-                try (final CloseableIterator<?> initialKeysIterator = ChunkedColumnIterator.make(
-                        setKeySource, setTable.getRowSet(), getChunkSize(setTable.getRowSet()))) {
-                    initialKeysIterator.forEachRemaining(this::addKey);
-                }
-            }
+            this.setTable = setTable;
 
             final String[] setColumnNames =
-                    Arrays.stream(matchPairs).map(MatchPair::rightColumn).toArray(String[]::new);
+                    Arrays.stream(this.sourceToSetColumnNamePairs).map(MatchPair::rightColumn).toArray(String[]::new);
             final ModifiedColumnSet setColumnsMCS = setTable.newModifiedColumnSet(setColumnNames);
-            this.setTable = setTable;
             setUpdateListener = new InstrumentedTableUpdateListenerAdapter(
-                    "DynamicWhereFilter(" + Arrays.toString(setColumnsNames) + ")", setTable, false) {
+                    "DynamicWhereFilter(" + Arrays.toString(sourceToSetColumnNamePairs) + ")", setTable, false) {
 
                 @Override
                 public void onUpdate(final TableUpdate upstream) {
@@ -181,15 +182,7 @@ public void onFailureInternal(Throwable originalException, Entry sourceEntry) {
             manage(setUpdateListener);
         } else {
             this.setTable = null;
-            setKeySource = null;
             setUpdateListener = null;
-            if (setTable.getRowSet().isNonempty()) {
-                final ChunkSource.WithPrev<Values> tmpKeySource = DataIndexUtils.makeBoxedKeySource(setColumns);
-                try (final CloseableIterator<?> initialKeysIterator = ChunkedColumnIterator.make(
-                        tmpKeySource, setTable.getRowSet(), getChunkSize(setTable.getRowSet()))) {
-                    initialKeysIterator.forEachRemaining(this::addKeyUnchecked);
-                }
-            }
         }
     }
 
@@ -197,14 +190,15 @@ public void onFailureInternal(Throwable originalException, Entry sourceEntry) {
      * "Copy constructor" for DynamicWhereFilter's with static set tables.
      */
     private DynamicWhereFilter(
-            @NotNull final DataIndexKeySet liveValues,
+            @NotNull final Class<?> @NotNull [] setKeyTypes,
+            @NotNull final SetInclusionKernel setKernel,
             final boolean inclusion,
-            final MatchPair... setColumnsNames) {
-        this.liveValues = liveValues;
-        this.matchPairs = setColumnsNames;
+            final MatchPair... sourceToSetColumnNamePairs) {
+        this.setKeyTypes = setKeyTypes;
+        this.setKernel = setKernel;
         this.inclusion = inclusion;
+        this.sourceToSetColumnNamePairs = sourceToSetColumnNamePairs;
         setTable = null;
-        setKeySource = null;
         setUpdateListener = null;
     }
 
@@ -214,23 +208,19 @@ public UpdateGraph getUpdateGraph() {
     }
 
     private void removeKey(Object key) {
-        final boolean removed = liveValues.remove(key);
-        if (!removed && key != null) {
+        if (!setKernel.remove(key)) {
             throw new RuntimeException("Inconsistent state, key not found in set: " + key);
         }
-        liveValuesArray = null;
     }
 
     private void addKey(Object key) {
-        final boolean added = liveValues.add(key);
-        if (!added) {
+        if (!setKernel.add(key)) {
             throw new RuntimeException("Inconsistent state, key already in set:" + key);
         }
-        liveValuesArray = null;
     }
 
     private void addKeyUnchecked(Object key) {
-        liveValues.add(key);
+        setKernel.add(key);
     }
 
     /**
@@ -245,8 +235,8 @@ public SafeCloseable beginOperation(@NotNull final Table sourceTable) {
             throw new IllegalStateException("Inputs already initialized, use copy() instead of re-using a WhereFilter");
         }
         getUpdateGraph(this, sourceTable);
-        final String[] keyColumnNames = MatchPair.getLeftColumns(matchPairs);
-        sourceKeyColumns = Arrays.stream(matchPairs)
+        final String[] keyColumnNames = MatchPair.getLeftColumns(sourceToSetColumnNamePairs);
+        sourceKeyColumns = Arrays.stream(sourceToSetColumnNamePairs)
                 .map(mp -> sourceTable.getColumnSource(mp.leftColumn())).toArray(ColumnSource[]::new);
         try (final SafeCloseable ignored = sourceTable.isRefreshing() ? LivenessScopeStack.open() : null) {
             sourceDataIndex = optimalIndex(sourceTable, keyColumnNames);
@@ -254,9 +244,48 @@ public SafeCloseable beginOperation(@NotNull final Table sourceTable) {
                 if (sourceDataIndex.isRefreshing()) {
                     manage(sourceDataIndex);
                 }
-                indexToSetKeyOffsets = computeIndexToSetKeyOffsets(sourceDataIndex, sourceKeyColumns);
+                computeTupleIndexMaps();
+            }
+        }
+
+        final ColumnSource<?>[] reinterpretedSourceKeyColumns = Arrays.stream(sourceKeyColumns)
+                .map(ReinterpretUtils::maybeConvertToPrimitive)
+                .toArray(ColumnSource[]::new);
+        for (int ki = 0; ki < setKeyTypes.length; ++ki) {
+            if (setKeyTypes[ki] != reinterpretedSourceKeyColumns[ki].getType()) {
+                throw new IllegalArgumentException(String.format(
+                        "Reinterpreted key type mismatch: (set key type) %s != %s (source key type)",
+                        setKeyTypes[ki], reinterpretedSourceKeyColumns[ki].getType()));
             }
         }
+        sourceKeySource = TupleSourceFactory.makeTupleSource(reinterpretedSourceKeyColumns);
+
+        if (setTable == null // Set table is static
+                && staticSetLookupKeys == null // We haven't already computed the lookup keys
+                && sourceDataIndex != null // We might use the lookup keys if we compute them
+                && sourceDataIndex.isRefreshing() // We might use the lookup keys more than once
+                && sourceKeyColumns.length > 1 // Making a lookup key is more complicated than boxing a primitive
+        ) {
+            // Convert the tuples in liveValues to be lookup keys in the sourceDataIndex
+            staticSetLookupKeys = new ArrayList<>(setKernel.size());
+            final int indexKeySize = sourceDataIndex.keyColumns().length;
+            if (indexKeySize > 1) {
+                final Function<Object, Object> keyMappingFunction = indexKeySize == keyColumnNames.length
+                        ? tupleToFullKeyMappingFunction()
+                        : tupleToPartialKeyMappingFunction();
+
+                setKernel.iterator().forEachRemaining(key -> {
+                    final Object[] lookupKey = (Object[]) keyMappingFunction.apply(key);
+                    // Store a copy because the mapping function returns the same array each invocation.
+                    staticSetLookupKeys.add(Arrays.copyOf(lookupKey, indexKeySize));
+                });
+            } else {
+                final int keyOffset = indexToTupleMap == null ? 0 : indexToTupleMap[0];
+                setKernel.iterator().forEachRemaining(
+                        key -> staticSetLookupKeys.add(sourceKeySource.exportElement(key, keyOffset)));
+            }
+        }
+
         return () -> {
         };
     }
@@ -275,79 +304,97 @@ private static DataIndex optimalIndex(final Table inputTable, final String[] key
     }
 
     /**
-     * Calculates a mapping from the index of a {@link ColumnSource} in the data index to the index of the corresponding
-     * {@link ColumnSource} in the key sources from the source table for a DynamicWhereFilter. This allows for mapping
-     * keys from the {@link #liveValues} to keys in the {@link #sourceDataIndex}.
-     *
-     * @param dataIndex The {@link DataIndex} to use for the mapping
-     * @param keySources The key {@link ColumnSource ColumnSources} from the source table
-     * @return A mapping from the data index source offset to the key source offset for the same {@link ColumnSource},
-     *         or {@code null} if there is no mapping needed (because {@code dataIndex} and {@code keySources} have the
-     *         same columns in the same order
+     * Calculates mappings from the offset of a {@link ColumnSource} in the {@code sourceDataIndex} to the offset of the
+     * corresponding {@link ColumnSource} in the key sources from the set or source table of a DynamicWhereFilter
+     * ({@code indexToTupleMap}, as well as the reverse ({@code tupleToIndexMap}). This allows for mapping keys from the
+     * {@link #setKernel} to keys in the {@link #sourceDataIndex}.
      */
-    private static int[] computeIndexToSetKeyOffsets(
-            @NotNull final DataIndex dataIndex,
-            @NotNull final ColumnSource<?>[] keySources) {
-
-        final class SourceOffsetPair {
+    private void computeTupleIndexMaps() {
+        assert sourceDataIndex != null;
 
-            private final ColumnSource<?> source;
-            private final int offset;
-
-            private SourceOffsetPair(@NotNull final ColumnSource<?> source, final int offset) {
-                this.source = source;
-                this.offset = offset;
-            }
+        if (sourceDataIndex.keyColumns().length == 1) {
+            // Trivial mapping, no need to compute anything.
+            return;
         }
 
-        final MutableInt dataIndexSourceOffset = new MutableInt(0);
-        final KeyedObjectHashMap<ColumnSource<?>, SourceOffsetPair> dataIndexSources =
-                dataIndex.keyColumnNamesByIndexedColumn().keySet()
-                        .stream()
-                        .collect(Collectors.toMap(
-                                cs -> cs,
-                                cs -> new SourceOffsetPair(cs, dataIndexSourceOffset.getAndIncrement()),
-                                Assert::neverInvoked,
-                                () -> new KeyedObjectHashMap<>(new KeyedObjectKey.ExactAdapter<>(sop -> sop.source))));
-
-        final int[] indexToKeySourceOffsets = new int[dataIndexSources.size()];
-        boolean isAscending = true;
-        for (int kci = 0; kci < keySources.length; ++kci) {
-            final SourceOffsetPair dataIndexSource = dataIndexSources.get(keySources[kci]);
-            if (dataIndexSource != null) {
-                indexToKeySourceOffsets[dataIndexSource.offset] = kci;
-                isAscending &= dataIndexSource.offset == kci;
-                if (dataIndexSourceOffset.decrementAndGet() == 0) {
-                    return isAscending && keySources.length == indexToKeySourceOffsets.length
-                            ? null
-                            : indexToKeySourceOffsets;
+        final ColumnSource<?>[] dataIndexSources = sourceDataIndex
+                .keyColumnNamesByIndexedColumn()
+                .keySet()
+                .toArray(ColumnSource.ZERO_LENGTH_COLUMN_SOURCE_ARRAY);
+
+        // Bi-directional mapping (note that the sizes can be different, e.g. partial matching).
+        final int[] tupleToIndexMap = new int[sourceKeyColumns.length];
+        final int[] indexToTupleMap = new int[dataIndexSources.length];
+
+        // Fill with -1 to indicate no mapping. This value will remain in the case of a partial index to indicate that
+        // the key column is not in the index, thereby poisoning any mistaken attempt to use the mapping.
+        Arrays.fill(tupleToIndexMap, -1);
+
+        boolean sameOrder = true;
+
+        // The tuples will be in sourceKeyColumns order (same as set table key columns order). We need to find the
+        // dataIndex offset for each key source.
+        for (int ii = 0; ii < sourceKeyColumns.length; ++ii) {
+            for (int jj = 0; jj < dataIndexSources.length; ++jj) {
+                if (sourceKeyColumns[ii] == dataIndexSources[jj]) {
+                    tupleToIndexMap[ii] = jj;
+                    indexToTupleMap[jj] = ii;
+                    sameOrder &= ii == jj;
+                    break;
                 }
             }
         }
 
-        throw new IllegalArgumentException(String.format(
-                "The provided key sources %s don't match the data index key sources %s",
-                Arrays.toString(keySources), dataIndex.keyColumnNamesByIndexedColumn().keySet()));
+        // Return null if the map is the identity map
+        this.tupleToIndexMap = sameOrder ? null : tupleToIndexMap;
+        this.indexToTupleMap = sameOrder ? null : indexToTupleMap;
     }
 
     @NotNull
-    private Function<Object, Object> compoundKeyMappingFunction() {
-        if (indexToSetKeyOffsets == null) {
-            return Function.identity();
+    private Function<Object, Object> tupleToFullKeyMappingFunction() {
+        final Object[] keysInDataIndexOrder = new Object[sourceKeyColumns.length];
+        if (tupleToIndexMap == null) {
+            return (final Object tupleKey) -> {
+                sourceKeySource.exportAllTo(keysInDataIndexOrder, tupleKey);
+                return keysInDataIndexOrder;
+            };
         }
-        final Object[] keysInDataIndexOrder = new Object[indexToSetKeyOffsets.length];
-        return (final Object key) -> {
-            final Object[] keysInSetOrder = (Object[]) key;
-            for (int ki = 0; ki < keysInDataIndexOrder.length; ++ki) {
-                keysInDataIndexOrder[ki] = keysInSetOrder[indexToSetKeyOffsets[ki]];
-            }
+        return (final Object tupleKey) -> {
+            sourceKeySource.exportAllTo(keysInDataIndexOrder, tupleKey, tupleToIndexMap);
             return keysInDataIndexOrder;
         };
     }
 
+    @NotNull
+    private Function<Object, Object> tupleToPartialKeyMappingFunction() {
+        assert sourceDataIndex != null;
+
+        final int partialKeySize = sourceDataIndex.keyColumns().length;
+
+        // This function is not needed when the partial key is a single column and should not be called.
+        Assert.gt(partialKeySize, "partialKeySize", 1);
+
+        final Object[] keysInDataIndexOrder = new Object[partialKeySize];
+        if (indexToTupleMap == null) {
+            return (final Object tupleKey) -> {
+                for (int ii = 0; ii < partialKeySize; ++ii) {
+                    keysInDataIndexOrder[ii] = sourceKeySource.exportElement(tupleKey, ii);
+                }
+                return keysInDataIndexOrder;
+            };
+        } else {
+            return (final Object tupleKey) -> {
+                for (int ii = 0; ii < partialKeySize; ++ii) {
+                    keysInDataIndexOrder[ii] = sourceKeySource.exportElement(tupleKey, indexToTupleMap[ii]);
+                }
+                return keysInDataIndexOrder;
+            };
+        }
+    }
+
     @Override
     public List<String> getColumns() {
-        return Arrays.asList(MatchPair.getLeftColumns(matchPairs));
+        return Arrays.asList(MatchPair.getLeftColumns(sourceToSetColumnNamePairs));
     }
 
     @Override
@@ -369,16 +416,6 @@ public WritableRowSet filter(
             throw new PreviousFilteringNotSupported();
         }
 
-        if (matchPairs.length == 1) {
-            // Single column filter, delegate to the column source.
-            if (liveValuesArray == null) {
-                liveValuesArray = liveValues.toArray();
-            }
-            // Our keys are reinterpreted, so we need to reinterpret the column source for correct matching.
-            final ColumnSource<?> source = ReinterpretUtils.maybeConvertToPrimitive(sourceKeyColumns[0]);
-            return source.match(!inclusion, false, false, sourceDataIndex, selection, liveValuesArray);
-        }
-
         if (sourceDataIndex != null) {
             // Does our index contain every key column?
 
@@ -402,15 +439,26 @@ public WritableRowSet filter(
     @NotNull
     private WritableRowSet filterFullIndex(@NotNull final RowSet selection) {
         Assert.neqNull(sourceDataIndex, "sourceDataIndex");
-        Assert.gt(sourceKeyColumns.length, "sourceKeyColumns.length", 1);
 
         final WritableRowSet filtered = inclusion ? RowSetFactory.empty() : selection.copy();
         // noinspection DataFlowIssue
         final DataIndex.RowKeyLookup rowKeyLookup = sourceDataIndex.rowKeyLookup();
         final ColumnSource<RowSet> rowSetColumn = sourceDataIndex.rowSetColumn();
-        final Function<Object, Object> keyMappingFunction = compoundKeyMappingFunction();
 
-        liveValues.forEach(key -> {
+        final Iterator<Object> values;
+        final Function<Object, Object> keyMappingFunction;
+        if (staticSetLookupKeys != null) {
+            values = staticSetLookupKeys.iterator();
+            keyMappingFunction = Function.identity();
+        } else if (sourceKeyColumns.length == 1) {
+            values = setKernel.iterator();
+            keyMappingFunction = Function.identity();
+        } else {
+            values = setKernel.iterator();
+            keyMappingFunction = tupleToFullKeyMappingFunction();
+        }
+
+        values.forEachRemaining(key -> {
             final Object mappedKey = keyMappingFunction.apply(key);
             final long rowKey = rowKeyLookup.apply(mappedKey, false);
             final RowSet rowSet = rowSetColumn.get(rowKey);
@@ -440,35 +488,33 @@ private WritableRowSet filterPartialIndex(@NotNull final RowSet selection) {
             final DataIndex.RowKeyLookup rowKeyLookup = sourceDataIndex.rowKeyLookup();
             final ColumnSource<RowSet> rowSetColumn = sourceDataIndex.rowSetColumn();
 
-            if (indexToSetKeyOffsets.length == 1) {
-                // We could delegate to the column source, but we'd have to create a single-column view of liveValues.
-
-                // Only one indexed source, so we can use the RowSetLookup directly on the right sub-key.
-                final int keyOffset = indexToSetKeyOffsets[0];
-                liveValues.forEach(key -> {
-                    final Object[] keysInSetOrder = (Object[]) key;
-                    final long rowKey = rowKeyLookup.apply(keysInSetOrder[keyOffset], false);
-                    final RowSet rowSet = rowSetColumn.get(rowKey);
-                    if (rowSet != null) {
-                        try (final RowSet intersected = rowSet.intersect(selection)) {
-                            possiblyMatching.insert(intersected);
-                        }
-                    }
-                });
+            final Iterator<Object> values;
+            final Function<Object, Object> keyMappingFunction;
+
+            if (staticSetLookupKeys != null) {
+                values = staticSetLookupKeys.iterator();
+                keyMappingFunction = Function.identity();
             } else {
-                final Function<Object, Object> keyMappingFunction = compoundKeyMappingFunction();
-                liveValues.forEach(key -> {
-                    final Object mappedKey = keyMappingFunction.apply(key);
-                    final long rowKey = rowKeyLookup.apply(mappedKey, false);
-                    final RowSet rowSet = rowSetColumn.get(rowKey);
-                    if (rowSet != null) {
-                        try (final RowSet intersected = rowSet.intersect(selection)) {
-                            possiblyMatching.insert(intersected);
-                        }
-                    }
-                });
+                values = setKernel.iterator();
+                if (sourceDataIndex.keyColumnNames().size() == 1) {
+                    final int keyOffset = indexToTupleMap == null ? 0 : indexToTupleMap[0];
+                    keyMappingFunction = (final Object key) -> sourceKeySource.exportElement(key, keyOffset);
+                } else {
+                    keyMappingFunction = tupleToPartialKeyMappingFunction();
+                }
             }
 
+            values.forEachRemaining(key -> {
+                final Object lookupKey = keyMappingFunction.apply(key);
+                final long rowKey = rowKeyLookup.apply(lookupKey, false);
+                final RowSet rowSet = rowSetColumn.get(rowKey);
+                if (rowSet != null) {
+                    try (final RowSet intersected = rowSet.intersect(selection)) {
+                        possiblyMatching.insert(intersected);
+                    }
+                }
+            });
+
             // Now, do linear filter on possiblyMatching to determine the values to include or exclude from selection.
             matching = filterLinear(possiblyMatching, true);
         }
@@ -481,33 +527,35 @@ private WritableRowSet filterPartialIndex(@NotNull final RowSet selection) {
     }
 
     private WritableRowSet filterLinear(final RowSet selection, final boolean filterInclusion) {
-        // Any single column filter is pushed through AbstractColumnSource.match()
-        Assert.gt(sourceKeyColumns.length, "sourceKeyColumns.length", 1);
-
-        final RowSetBuilderSequential indexBuilder = RowSetFactory.builderSequential();
+        if (selection.isEmpty()) {
+            return RowSetFactory.empty();
+        }
 
-        final ChunkSource<Values> keySource = DataIndexUtils.makeBoxedKeySource(sourceKeyColumns);
+        final RowSetBuilderSequential filteredRowSetBuilder = RowSetFactory.builderSequential();
 
         final int maxChunkSize = getChunkSize(selection);
         // @formatter:off
-        try (final ChunkSource.GetContext keyGetContext = keySource.makeGetContext(maxChunkSize);
-             final RowSequence.Iterator selectionIterator = selection.getRowSequenceIterator()) {
+        try (final ColumnSource.GetContext keyGetContext = sourceKeySource.makeGetContext(maxChunkSize);
+             final RowSequence.Iterator selectionIterator = selection.getRowSequenceIterator();
+             final WritableBooleanChunk<Values> matches = WritableBooleanChunk.makeWritableChunk(maxChunkSize)) {
             // @formatter:on
 
             while (selectionIterator.hasMore()) {
                 final RowSequence selectionChunk = selectionIterator.getNextRowSequenceWithLength(maxChunkSize);
                 final LongChunk<OrderedRowKeys> selectionRowKeyChunk = selectionChunk.asRowKeyChunk();
-                final ObjectChunk<Object, ? extends Values> keyChunk =
-                        keySource.getChunk(keyGetContext, selectionChunk).asObjectChunk();
-                final int thisChunkSize = keyChunk.size();
+                final Chunk<Values> keyChunk = Chunk.downcast(sourceKeySource.getChunk(keyGetContext, selectionChunk));
+                setKernel.matchValues(keyChunk, matches, filterInclusion);
 
+                final int thisChunkSize = keyChunk.size();
                 for (int ii = 0; ii < thisChunkSize; ++ii) {
-                    if (liveValues.contains(keyChunk.get(ii)) == filterInclusion)
-                        indexBuilder.appendKey(selectionRowKeyChunk.get(ii));
+                    if (matches.get(ii)) {
+                        filteredRowSetBuilder.appendKey(selectionRowKeyChunk.get(ii));
+                    }
                 }
             }
         }
-        return indexBuilder.build();
+
+        return filteredRowSetBuilder.build();
     }
 
     private static int getChunkSize(@NotNull final RowSet selection) {
@@ -537,9 +585,9 @@ public void setRecomputeListener(RecomputeListener listener) {
     @Override
     public DynamicWhereFilter copy() {
         if (setTable == null) {
-            return new DynamicWhereFilter(liveValues, inclusion, matchPairs);
+            return new DynamicWhereFilter(setKeyTypes, setKernel, inclusion, sourceToSetColumnNamePairs);
         }
-        return new DynamicWhereFilter(setTable, inclusion, matchPairs);
+        return new DynamicWhereFilter(setTable, inclusion, sourceToSetColumnNamePairs);
     }
 
     @Override
@@ -550,7 +598,8 @@ public boolean satisfied(final long step) {
 
     @Override
     public LogOutput append(LogOutput logOutput) {
-        return logOutput.append("DynamicWhereFilter(").append(MatchPair.MATCH_PAIR_ARRAY_FORMATTER, matchPairs)
-                .append(")");
+        return logOutput.append("DynamicWhereFilter(")
+                .append(MatchPair.MATCH_PAIR_ARRAY_FORMATTER, sourceToSetColumnNamePairs)
+                .append(')');
     }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ByteSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ByteSetInclusionKernel.java
index b48f89c995a..81f3deebd05 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ByteSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ByteSetInclusionKernel.java
@@ -7,15 +7,20 @@
 // @formatter:off
 package io.deephaven.engine.table.impl.select.setinclusion;
 
-import io.deephaven.chunk.*;
+import gnu.trove.iterator.TByteIterator;
+import io.deephaven.chunk.ByteChunk;
+import io.deephaven.chunk.Chunk;
+import io.deephaven.chunk.WritableBooleanChunk;
 import io.deephaven.chunk.attributes.Values;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TByteSet;
 import gnu.trove.set.hash.TByteHashSet;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
 
 public class ByteSetInclusionKernel implements SetInclusionKernel {
+
     private final TByteSet liveValues;
     private final boolean inclusion;
 
@@ -25,14 +30,66 @@ public class ByteSetInclusionKernel implements SetInclusionKernel {
         this.inclusion = inclusion;
     }
 
+    ByteSetInclusionKernel(boolean inclusion) {
+        this.liveValues = new TByteHashSet();
+        this.inclusion = inclusion;
+    }
+
+    @Override
+    public boolean add(Object key) {
+        return liveValues.add(TypeUtils.unbox((Byte) key));
+    }
+
+    @Override
+    public boolean remove(Object key) {
+        return liveValues.remove(TypeUtils.unbox((Byte) key));
+    }
+
+    @Override
+    public int size() {
+        return liveValues.size();
+    }
+
+    private static final class Iterator implements java.util.Iterator<Object> {
+
+        private final TByteIterator inner;
+
+        private Iterator(@NotNull final TByteIterator inner) {
+            this.inner = inner;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return inner.hasNext();
+        }
+
+        @Override
+        public Byte next() {
+            return TypeUtils.box(inner.next());
+        }
+    }
+
+    @Override
+    public java.util.Iterator<Object> iterator() {
+        return new Iterator(liveValues.iterator());
+    }
+
+    @Override
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
+        matchValues(values.asByteChunk(), matches, inclusion);
+    }
+
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk matches) {
-        matchValues(values.asByteChunk(), matches);
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
+        matchValues(values.asByteChunk(), matches, inclusionOverride);
     }
 
-    private void matchValues(ByteChunk<Values> values, WritableBooleanChunk matches) {
+    private void matchValues(
+            ByteChunk<Values> values,
+            WritableBooleanChunk<?> matches,
+            boolean inclusionToUse) {
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusion);
+            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
         }
         matches.setSize(values.size());
     }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/CharSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/CharSetInclusionKernel.java
index 3421c46e85d..179fd8a32b0 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/CharSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/CharSetInclusionKernel.java
@@ -3,15 +3,20 @@
 //
 package io.deephaven.engine.table.impl.select.setinclusion;
 
-import io.deephaven.chunk.*;
+import gnu.trove.iterator.TCharIterator;
+import io.deephaven.chunk.CharChunk;
+import io.deephaven.chunk.Chunk;
+import io.deephaven.chunk.WritableBooleanChunk;
 import io.deephaven.chunk.attributes.Values;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TCharSet;
 import gnu.trove.set.hash.TCharHashSet;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
 
 public class CharSetInclusionKernel implements SetInclusionKernel {
+
     private final TCharSet liveValues;
     private final boolean inclusion;
 
@@ -21,14 +26,66 @@ public class CharSetInclusionKernel implements SetInclusionKernel {
         this.inclusion = inclusion;
     }
 
+    CharSetInclusionKernel(boolean inclusion) {
+        this.liveValues = new TCharHashSet();
+        this.inclusion = inclusion;
+    }
+
+    @Override
+    public boolean add(Object key) {
+        return liveValues.add(TypeUtils.unbox((Character) key));
+    }
+
+    @Override
+    public boolean remove(Object key) {
+        return liveValues.remove(TypeUtils.unbox((Character) key));
+    }
+
+    @Override
+    public int size() {
+        return liveValues.size();
+    }
+
+    private static final class Iterator implements java.util.Iterator<Object> {
+
+        private final TCharIterator inner;
+
+        private Iterator(@NotNull final TCharIterator inner) {
+            this.inner = inner;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return inner.hasNext();
+        }
+
+        @Override
+        public Character next() {
+            return TypeUtils.box(inner.next());
+        }
+    }
+
+    @Override
+    public java.util.Iterator<Object> iterator() {
+        return new Iterator(liveValues.iterator());
+    }
+
+    @Override
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
+        matchValues(values.asCharChunk(), matches, inclusion);
+    }
+
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk matches) {
-        matchValues(values.asCharChunk(), matches);
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
+        matchValues(values.asCharChunk(), matches, inclusionOverride);
     }
 
-    private void matchValues(CharChunk<Values> values, WritableBooleanChunk matches) {
+    private void matchValues(
+            CharChunk<Values> values,
+            WritableBooleanChunk<?> matches,
+            boolean inclusionToUse) {
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusion);
+            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
         }
         matches.setSize(values.size());
     }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/DoubleSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/DoubleSetInclusionKernel.java
index 27bf820aac4..19ee26801a3 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/DoubleSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/DoubleSetInclusionKernel.java
@@ -7,15 +7,20 @@
 // @formatter:off
 package io.deephaven.engine.table.impl.select.setinclusion;
 
-import io.deephaven.chunk.*;
+import gnu.trove.iterator.TDoubleIterator;
+import io.deephaven.chunk.DoubleChunk;
+import io.deephaven.chunk.Chunk;
+import io.deephaven.chunk.WritableBooleanChunk;
 import io.deephaven.chunk.attributes.Values;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TDoubleSet;
 import gnu.trove.set.hash.TDoubleHashSet;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
 
 public class DoubleSetInclusionKernel implements SetInclusionKernel {
+
     private final TDoubleSet liveValues;
     private final boolean inclusion;
 
@@ -25,14 +30,66 @@ public class DoubleSetInclusionKernel implements SetInclusionKernel {
         this.inclusion = inclusion;
     }
 
+    DoubleSetInclusionKernel(boolean inclusion) {
+        this.liveValues = new TDoubleHashSet();
+        this.inclusion = inclusion;
+    }
+
+    @Override
+    public boolean add(Object key) {
+        return liveValues.add(TypeUtils.unbox((Double) key));
+    }
+
+    @Override
+    public boolean remove(Object key) {
+        return liveValues.remove(TypeUtils.unbox((Double) key));
+    }
+
+    @Override
+    public int size() {
+        return liveValues.size();
+    }
+
+    private static final class Iterator implements java.util.Iterator<Object> {
+
+        private final TDoubleIterator inner;
+
+        private Iterator(@NotNull final TDoubleIterator inner) {
+            this.inner = inner;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return inner.hasNext();
+        }
+
+        @Override
+        public Double next() {
+            return TypeUtils.box(inner.next());
+        }
+    }
+
+    @Override
+    public java.util.Iterator<Object> iterator() {
+        return new Iterator(liveValues.iterator());
+    }
+
+    @Override
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
+        matchValues(values.asDoubleChunk(), matches, inclusion);
+    }
+
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk matches) {
-        matchValues(values.asDoubleChunk(), matches);
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
+        matchValues(values.asDoubleChunk(), matches, inclusionOverride);
     }
 
-    private void matchValues(DoubleChunk<Values> values, WritableBooleanChunk matches) {
+    private void matchValues(
+            DoubleChunk<Values> values,
+            WritableBooleanChunk<?> matches,
+            boolean inclusionToUse) {
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusion);
+            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
         }
         matches.setSize(values.size());
     }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/FloatSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/FloatSetInclusionKernel.java
index 6238c6ca2a1..d22400b1d9b 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/FloatSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/FloatSetInclusionKernel.java
@@ -7,15 +7,20 @@
 // @formatter:off
 package io.deephaven.engine.table.impl.select.setinclusion;
 
-import io.deephaven.chunk.*;
+import gnu.trove.iterator.TFloatIterator;
+import io.deephaven.chunk.FloatChunk;
+import io.deephaven.chunk.Chunk;
+import io.deephaven.chunk.WritableBooleanChunk;
 import io.deephaven.chunk.attributes.Values;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TFloatSet;
 import gnu.trove.set.hash.TFloatHashSet;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
 
 public class FloatSetInclusionKernel implements SetInclusionKernel {
+
     private final TFloatSet liveValues;
     private final boolean inclusion;
 
@@ -25,14 +30,66 @@ public class FloatSetInclusionKernel implements SetInclusionKernel {
         this.inclusion = inclusion;
     }
 
+    FloatSetInclusionKernel(boolean inclusion) {
+        this.liveValues = new TFloatHashSet();
+        this.inclusion = inclusion;
+    }
+
+    @Override
+    public boolean add(Object key) {
+        return liveValues.add(TypeUtils.unbox((Float) key));
+    }
+
+    @Override
+    public boolean remove(Object key) {
+        return liveValues.remove(TypeUtils.unbox((Float) key));
+    }
+
+    @Override
+    public int size() {
+        return liveValues.size();
+    }
+
+    private static final class Iterator implements java.util.Iterator<Object> {
+
+        private final TFloatIterator inner;
+
+        private Iterator(@NotNull final TFloatIterator inner) {
+            this.inner = inner;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return inner.hasNext();
+        }
+
+        @Override
+        public Float next() {
+            return TypeUtils.box(inner.next());
+        }
+    }
+
+    @Override
+    public java.util.Iterator<Object> iterator() {
+        return new Iterator(liveValues.iterator());
+    }
+
+    @Override
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
+        matchValues(values.asFloatChunk(), matches, inclusion);
+    }
+
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk matches) {
-        matchValues(values.asFloatChunk(), matches);
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
+        matchValues(values.asFloatChunk(), matches, inclusionOverride);
     }
 
-    private void matchValues(FloatChunk<Values> values, WritableBooleanChunk matches) {
+    private void matchValues(
+            FloatChunk<Values> values,
+            WritableBooleanChunk<?> matches,
+            boolean inclusionToUse) {
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusion);
+            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
         }
         matches.setSize(values.size());
     }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/IntSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/IntSetInclusionKernel.java
index 4d4a6b95e29..ae8d152b0d6 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/IntSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/IntSetInclusionKernel.java
@@ -7,15 +7,20 @@
 // @formatter:off
 package io.deephaven.engine.table.impl.select.setinclusion;
 
-import io.deephaven.chunk.*;
+import gnu.trove.iterator.TIntIterator;
+import io.deephaven.chunk.IntChunk;
+import io.deephaven.chunk.Chunk;
+import io.deephaven.chunk.WritableBooleanChunk;
 import io.deephaven.chunk.attributes.Values;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TIntSet;
 import gnu.trove.set.hash.TIntHashSet;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
 
 public class IntSetInclusionKernel implements SetInclusionKernel {
+
     private final TIntSet liveValues;
     private final boolean inclusion;
 
@@ -25,14 +30,66 @@ public class IntSetInclusionKernel implements SetInclusionKernel {
         this.inclusion = inclusion;
     }
 
+    IntSetInclusionKernel(boolean inclusion) {
+        this.liveValues = new TIntHashSet();
+        this.inclusion = inclusion;
+    }
+
+    @Override
+    public boolean add(Object key) {
+        return liveValues.add(TypeUtils.unbox((Integer) key));
+    }
+
+    @Override
+    public boolean remove(Object key) {
+        return liveValues.remove(TypeUtils.unbox((Integer) key));
+    }
+
+    @Override
+    public int size() {
+        return liveValues.size();
+    }
+
+    private static final class Iterator implements java.util.Iterator<Object> {
+
+        private final TIntIterator inner;
+
+        private Iterator(@NotNull final TIntIterator inner) {
+            this.inner = inner;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return inner.hasNext();
+        }
+
+        @Override
+        public Integer next() {
+            return TypeUtils.box(inner.next());
+        }
+    }
+
+    @Override
+    public java.util.Iterator<Object> iterator() {
+        return new Iterator(liveValues.iterator());
+    }
+
+    @Override
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
+        matchValues(values.asIntChunk(), matches, inclusion);
+    }
+
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk matches) {
-        matchValues(values.asIntChunk(), matches);
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
+        matchValues(values.asIntChunk(), matches, inclusionOverride);
     }
 
-    private void matchValues(IntChunk<Values> values, WritableBooleanChunk matches) {
+    private void matchValues(
+            IntChunk<Values> values,
+            WritableBooleanChunk<?> matches,
+            boolean inclusionToUse) {
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusion);
+            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
         }
         matches.setSize(values.size());
     }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/LongSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/LongSetInclusionKernel.java
index 95ca5e3b4fd..94342e30b00 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/LongSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/LongSetInclusionKernel.java
@@ -7,15 +7,20 @@
 // @formatter:off
 package io.deephaven.engine.table.impl.select.setinclusion;
 
-import io.deephaven.chunk.*;
+import gnu.trove.iterator.TLongIterator;
+import io.deephaven.chunk.LongChunk;
+import io.deephaven.chunk.Chunk;
+import io.deephaven.chunk.WritableBooleanChunk;
 import io.deephaven.chunk.attributes.Values;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TLongSet;
 import gnu.trove.set.hash.TLongHashSet;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
 
 public class LongSetInclusionKernel implements SetInclusionKernel {
+
     private final TLongSet liveValues;
     private final boolean inclusion;
 
@@ -25,14 +30,66 @@ public class LongSetInclusionKernel implements SetInclusionKernel {
         this.inclusion = inclusion;
     }
 
+    LongSetInclusionKernel(boolean inclusion) {
+        this.liveValues = new TLongHashSet();
+        this.inclusion = inclusion;
+    }
+
+    @Override
+    public boolean add(Object key) {
+        return liveValues.add(TypeUtils.unbox((Long) key));
+    }
+
+    @Override
+    public boolean remove(Object key) {
+        return liveValues.remove(TypeUtils.unbox((Long) key));
+    }
+
+    @Override
+    public int size() {
+        return liveValues.size();
+    }
+
+    private static final class Iterator implements java.util.Iterator<Object> {
+
+        private final TLongIterator inner;
+
+        private Iterator(@NotNull final TLongIterator inner) {
+            this.inner = inner;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return inner.hasNext();
+        }
+
+        @Override
+        public Long next() {
+            return TypeUtils.box(inner.next());
+        }
+    }
+
+    @Override
+    public java.util.Iterator<Object> iterator() {
+        return new Iterator(liveValues.iterator());
+    }
+
+    @Override
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
+        matchValues(values.asLongChunk(), matches, inclusion);
+    }
+
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk matches) {
-        matchValues(values.asLongChunk(), matches);
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
+        matchValues(values.asLongChunk(), matches, inclusionOverride);
     }
 
-    private void matchValues(LongChunk<Values> values, WritableBooleanChunk matches) {
+    private void matchValues(
+            LongChunk<Values> values,
+            WritableBooleanChunk<?> matches,
+            boolean inclusionToUse) {
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusion);
+            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
         }
         matches.setSize(values.size());
     }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ObjectSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ObjectSetInclusionKernel.java
index 4daf860b08f..5c3744ce7f8 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ObjectSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ObjectSetInclusionKernel.java
@@ -9,24 +9,60 @@
 import io.deephaven.chunk.attributes.Values;
 
 import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
 
 public class ObjectSetInclusionKernel implements SetInclusionKernel {
+
     private final Collection<Object> liveValues;
     private final boolean inclusion;
 
     public ObjectSetInclusionKernel(Collection<Object> liveValues, boolean inclusion) {
-        this.liveValues = liveValues;
+        this.liveValues = new HashSet<>(liveValues);
         this.inclusion = inclusion;
     }
 
+    ObjectSetInclusionKernel(boolean inclusion) {
+        this.liveValues = new HashSet<>();
+        this.inclusion = inclusion;
+    }
+
+    @Override
+    public boolean add(Object key) {
+        return liveValues.add(key);
+    }
+
+    @Override
+    public boolean remove(Object key) {
+        return liveValues.remove(key);
+    }
+
+    @Override
+    public int size() {
+        return liveValues.size();
+    }
+
+    @Override
+    public Iterator<Object> iterator() {
+        return liveValues.iterator();
+    }
+
+    @Override
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
+        matchValues(values.asObjectChunk(), matches, inclusion);
+    }
+
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk matches) {
-        matchValues(values.asObjectChunk(), matches);
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
+        matchValues(values.asObjectChunk(), matches, inclusionOverride);
     }
 
-    private void matchValues(ObjectChunk<?, Values> values, WritableBooleanChunk matches) {
+    private void matchValues(
+            ObjectChunk<?, Values> values,
+            WritableBooleanChunk<?> matches,
+            boolean inclusionToUse) {
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusion);
+            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
         }
         matches.setSize(values.size());
     }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/SetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/SetInclusionKernel.java
index 915d1f9688a..e87b877c207 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/SetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/SetInclusionKernel.java
@@ -9,9 +9,21 @@
 import io.deephaven.chunk.attributes.Values;
 
 import java.util.Collection;
+import java.util.Iterator;
 
 public interface SetInclusionKernel {
-    void matchValues(Chunk<Values> values, WritableBooleanChunk matches);
+
+    void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches);
+
+    void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride);
+
+    boolean add(Object key);
+
+    boolean remove(Object key);
+
+    int size();
+
+    Iterator<Object> iterator();
 
     static SetInclusionKernel makeKernel(ChunkType type, Collection<Object> values, boolean inclusion) {
         switch (type) {
@@ -35,4 +47,27 @@ static SetInclusionKernel makeKernel(ChunkType type, Collection<Object> values,
                 throw new UnsupportedOperationException();
         }
     }
+
+    static SetInclusionKernel makeKernel(ChunkType type, boolean inclusion) {
+        switch (type) {
+            case Object:
+                return new ObjectSetInclusionKernel(inclusion);
+            case Char:
+                return new CharSetInclusionKernel(inclusion);
+            case Byte:
+                return new ByteSetInclusionKernel(inclusion);
+            case Short:
+                return new ShortSetInclusionKernel(inclusion);
+            case Int:
+                return new IntSetInclusionKernel(inclusion);
+            case Long:
+                return new LongSetInclusionKernel(inclusion);
+            case Double:
+                return new DoubleSetInclusionKernel(inclusion);
+            case Float:
+                return new FloatSetInclusionKernel(inclusion);
+            default:
+                throw new UnsupportedOperationException();
+        }
+    }
 }
diff --git a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ShortSetInclusionKernel.java b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ShortSetInclusionKernel.java
index 7a4a089b22d..a51675e685c 100644
--- a/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ShortSetInclusionKernel.java
+++ b/engine/table/src/main/java/io/deephaven/engine/table/impl/select/setinclusion/ShortSetInclusionKernel.java
@@ -7,15 +7,20 @@
 // @formatter:off
 package io.deephaven.engine.table.impl.select.setinclusion;
 
-import io.deephaven.chunk.*;
+import gnu.trove.iterator.TShortIterator;
+import io.deephaven.chunk.ShortChunk;
+import io.deephaven.chunk.Chunk;
+import io.deephaven.chunk.WritableBooleanChunk;
 import io.deephaven.chunk.attributes.Values;
 import io.deephaven.util.type.TypeUtils;
 import gnu.trove.set.TShortSet;
 import gnu.trove.set.hash.TShortHashSet;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.Collection;
 
 public class ShortSetInclusionKernel implements SetInclusionKernel {
+
     private final TShortSet liveValues;
     private final boolean inclusion;
 
@@ -25,14 +30,66 @@ public class ShortSetInclusionKernel implements SetInclusionKernel {
         this.inclusion = inclusion;
     }
 
+    ShortSetInclusionKernel(boolean inclusion) {
+        this.liveValues = new TShortHashSet();
+        this.inclusion = inclusion;
+    }
+
+    @Override
+    public boolean add(Object key) {
+        return liveValues.add(TypeUtils.unbox((Short) key));
+    }
+
+    @Override
+    public boolean remove(Object key) {
+        return liveValues.remove(TypeUtils.unbox((Short) key));
+    }
+
+    @Override
+    public int size() {
+        return liveValues.size();
+    }
+
+    private static final class Iterator implements java.util.Iterator<Object> {
+
+        private final TShortIterator inner;
+
+        private Iterator(@NotNull final TShortIterator inner) {
+            this.inner = inner;
+        }
+
+        @Override
+        public boolean hasNext() {
+            return inner.hasNext();
+        }
+
+        @Override
+        public Short next() {
+            return TypeUtils.box(inner.next());
+        }
+    }
+
+    @Override
+    public java.util.Iterator<Object> iterator() {
+        return new Iterator(liveValues.iterator());
+    }
+
+    @Override
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches) {
+        matchValues(values.asShortChunk(), matches, inclusion);
+    }
+
     @Override
-    public void matchValues(Chunk<Values> values, WritableBooleanChunk matches) {
-        matchValues(values.asShortChunk(), matches);
+    public void matchValues(Chunk<Values> values, WritableBooleanChunk<?> matches, boolean inclusionOverride) {
+        matchValues(values.asShortChunk(), matches, inclusionOverride);
     }
 
-    private void matchValues(ShortChunk<Values> values, WritableBooleanChunk matches) {
+    private void matchValues(
+            ShortChunk<Values> values,
+            WritableBooleanChunk<?> matches,
+            boolean inclusionToUse) {
         for (int ii = 0; ii < values.size(); ++ii) {
-            matches.set(ii, liveValues.contains(values.get(ii)) == inclusion);
+            matches.set(ii, liveValues.contains(values.get(ii)) == inclusionToUse);
         }
         matches.setSize(values.size());
     }
diff --git a/engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableWhereTest.java b/engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableWhereTest.java
index 429ca7ccd37..e4bd2b2cb10 100644
--- a/engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableWhereTest.java
+++ b/engine/table/src/test/java/io/deephaven/engine/table/impl/QueryTableWhereTest.java
@@ -232,26 +232,49 @@ public void testWhereOneOfTwo() {
 
     @Test
     public void testWhereInDependency() {
-        testWhereInDependencyInternal(false, false);
+        testWhereInDependencyInternal(false, false, true, true);
+        testWhereInDependencyInternal(false, false, true, false);
+        testWhereInDependencyInternal(false, false, false, true);
+        testWhereInDependencyInternal(false, false, false, false);
     }
 
     @Test
     public void testWhereInDependencyIndexed() {
-        testWhereInDependencyInternal(true, false);
-        testWhereInDependencyInternal(false, true);
-        testWhereInDependencyInternal(true, true);
+        testWhereInDependencyInternal(true, false, true, true);
+        testWhereInDependencyInternal(true, false, true, false);
+        testWhereInDependencyInternal(true, false, false, true);
+        testWhereInDependencyInternal(true, false, false, false);
+
+        testWhereInDependencyInternal(false, true, true, true);
+        testWhereInDependencyInternal(false, true, true, false);
+        testWhereInDependencyInternal(false, true, false, true);
+        testWhereInDependencyInternal(false, true, false, false);
+
+        testWhereInDependencyInternal(true, true, true, true);
+        testWhereInDependencyInternal(true, true, true, false);
+        testWhereInDependencyInternal(true, true, false, true);
+        testWhereInDependencyInternal(true, true, false, false);
     }
 
-    private void testWhereInDependencyInternal(boolean filterIndexed, boolean setIndexed) {
-        final QueryTable tableToFilter = testRefreshingTable(i(10, 11, 12, 13, 14, 15).toTracking(),
-                col("A", 1, 2, 3, 4, 5, 6), col("B", 2, 4, 6, 8, 10, 12), col("C", 'a', 'b', 'c', 'd', 'e', 'f'));
+    private void testWhereInDependencyInternal(
+            boolean filterIndexed,
+            boolean setIndexed,
+            boolean sourceRefreshing,
+            boolean setRefreshing) {
+
+        final QueryTable tableToFilter = sourceRefreshing
+                ? testRefreshingTable(i(10, 11, 12, 13, 14, 15).toTracking(), col("A", 1, 2, 3, 4, 5, 6),
+                        col("B", 2, 4, 6, 8, 10, 12), col("C", 'a', 'b', 'c', 'd', 'e', 'f'))
+                : testTable(i(10, 11, 12, 13, 14, 15).toTracking(), col("A", 1, 2, 3, 4, 5, 6),
+                        col("B", 2, 4, 6, 8, 10, 12), col("C", 'a', 'b', 'c', 'd', 'e', 'f'));
         if (filterIndexed) {
             DataIndexer.getOrCreateDataIndex(tableToFilter, "A");
             DataIndexer.getOrCreateDataIndex(tableToFilter, "B");
         }
 
-        final QueryTable setTable = testRefreshingTable(i(100, 101, 102).toTracking(),
-                col("A", 1, 2, 3), col("B", 2, 4, 6));
+        final QueryTable setTable = setRefreshing
+                ? testRefreshingTable(i(100, 101, 102).toTracking(), col("A", 1, 2, 3), col("B", 2, 4, 6))
+                : testTable(i(100, 101, 102).toTracking(), col("A", 1, 2, 3), col("B", 2, 4, 6));
         final Table setTable1 = setTable.where("A > 2");
         final Table setTable2 = setTable.where("B > 6");
         if (setIndexed) {
@@ -280,17 +303,19 @@ private void testWhereInDependencyInternal(boolean filterIndexed, boolean setInd
             TestCase.assertTrue(composed.satisfied(updateGraph.clock().currentStep()));
         });
 
-        updateGraph.runWithinUnitTestCycle(() -> {
-            addToTable(setTable, i(103), col("A", 5), col("B", 8));
-            setTable.notifyListeners(i(103), i(), i());
-        });
+        if (setRefreshing) {
+            updateGraph.runWithinUnitTestCycle(() -> {
+                addToTable(setTable, i(103), col("A", 5), col("B", 8));
+                setTable.notifyListeners(i(103), i(), i());
+            });
 
-        TableTools.show(composed);
+            TableTools.show(composed);
 
-        final Table expected =
-                TableTools.newTable(intCol("A", 3, 4, 5), intCol("B", 6, 8, 10), charCol("C", 'c', 'd', 'e'));
+            final Table expected =
+                    TableTools.newTable(intCol("A", 3, 4, 5), intCol("B", 6, 8, 10), charCol("C", 'c', 'd', 'e'));
 
-        assertTableEquals(composed, expected);
+            assertTableEquals(composed, expected);
+        }
     }
 
     @Test
@@ -351,17 +376,35 @@ public void testWhereDynamicIn() {
 
     @Test
     public void testWhereDynamicInIncremental() {
-        testWhereDynamicIncrementalInternal(false, false);
+        testWhereDynamicIncrementalInternal(false, false, true, true);
+        testWhereDynamicIncrementalInternal(false, false, true, false);
+        testWhereDynamicIncrementalInternal(false, false, false, true);
+        testWhereDynamicIncrementalInternal(false, false, false, false);
     }
 
     @Test
     public void testWhereDynamicInIncrementalIndexed() {
-        testWhereDynamicIncrementalInternal(true, false);
-        testWhereDynamicIncrementalInternal(false, true);
-        testWhereDynamicIncrementalInternal(true, true);
+        testWhereDynamicIncrementalInternal(true, false, true, true);
+        testWhereDynamicIncrementalInternal(true, false, true, false);
+        testWhereDynamicIncrementalInternal(true, false, false, true);
+        testWhereDynamicIncrementalInternal(true, false, false, false);
+
+        testWhereDynamicIncrementalInternal(false, true, true, true);
+        testWhereDynamicIncrementalInternal(false, true, true, false);
+        testWhereDynamicIncrementalInternal(false, true, false, true);
+        testWhereDynamicIncrementalInternal(false, true, false, false);
+
+        testWhereDynamicIncrementalInternal(true, true, true, true);
+        testWhereDynamicIncrementalInternal(true, true, true, false);
+        testWhereDynamicIncrementalInternal(true, true, false, true);
+        testWhereDynamicIncrementalInternal(true, true, false, false);
     }
 
-    private static void testWhereDynamicIncrementalInternal(boolean filterIndexed, boolean setIndexed) {
+    private static void testWhereDynamicIncrementalInternal(
+            boolean filterIndexed,
+            boolean setIndexed,
+            boolean sourceRefreshing,
+            boolean setRefreshing) {
         final ColumnInfo<?, ?>[] setInfo;
         final ColumnInfo<?, ?>[] filteredInfo;
 
@@ -372,7 +415,7 @@ private static void testWhereDynamicIncrementalInternal(boolean filterIndexed, b
         final String[] columnNames =
                 new String[] {"Sym", "intCol", "doubleCol", "charCol", "byteCol", "floatCol", "longCol", "shortCol"};
 
-        final QueryTable setTable = getTable(setSize, random, setInfo = initColumnInfos(
+        final QueryTable setTable = getTable(setRefreshing, setSize, random, setInfo = initColumnInfos(
                 columnNames,
                 new SetGenerator<>("aa", "bb"),
                 new IntGenerator(0, 10),
@@ -393,16 +436,17 @@ private static void testWhereDynamicIncrementalInternal(boolean filterIndexed, b
             DataIndexer.getOrCreateDataIndex(setTable, "Sym", "intCol");
         }
 
-        final QueryTable filteredTable = getTable(filteredSize, random, filteredInfo = initColumnInfos(
-                columnNames,
-                new SetGenerator<>("aa", "bb", "cc", "dd"),
-                new IntGenerator(0, 20),
-                new DoubleGenerator(0, 100),
-                new CharGenerator('a', 'z'),
-                new ByteGenerator((byte) 0, (byte) 127),
-                new SetGenerator<>(1.0f, 2.0f, 3.3f, null, 4.4f, 5.5f, 6.6f),
-                new LongGenerator(1500, 2500),
-                new ShortGenerator((short) 400, (short) 700)));
+        final QueryTable filteredTable = getTable(sourceRefreshing, filteredSize, random,
+                filteredInfo = initColumnInfos(
+                        columnNames,
+                        new SetGenerator<>("aa", "bb", "cc", "dd"),
+                        new IntGenerator(0, 20),
+                        new DoubleGenerator(0, 100),
+                        new CharGenerator('a', 'z'),
+                        new ByteGenerator((byte) 0, (byte) 127),
+                        new SetGenerator<>(1.0f, 2.0f, 3.3f, null, 4.4f, 5.5f, 6.6f),
+                        new LongGenerator(1500, 2500),
+                        new ShortGenerator((short) 400, (short) 700)));
 
         if (filterIndexed) {
             // Add an index on every column but "doubleCol"
@@ -436,31 +480,42 @@ private static void testWhereDynamicIncrementalInternal(boolean filterIndexed, b
                 EvalNugget.from(() -> filteredTable.whereNotIn(setTable, "floatCol")),
         };
 
+        validate(en);
+
         final ControlledUpdateGraph updateGraph = ExecutionContext.getContext().getUpdateGraph().cast();
         for (int step = 0; step < 100; step++) {
             final boolean modSet = random.nextInt(10) < 1;
             final boolean modFiltered = random.nextBoolean();
 
-            updateGraph.runWithinUnitTestCycle(() -> {
-                if (modSet) {
-                    GenerateTableUpdates.generateShiftAwareTableUpdates(GenerateTableUpdates.DEFAULT_PROFILE,
-                            setSize, random, setTable, setInfo);
-                }
-            });
-            validate(en);
+            if (setRefreshing) {
+                updateGraph.runWithinUnitTestCycle(() -> {
+                    if (modSet) {
+                        GenerateTableUpdates.generateShiftAwareTableUpdates(GenerateTableUpdates.DEFAULT_PROFILE,
+                                setSize, random, setTable, setInfo);
+                    }
+                });
+                validate(en);
+            }
 
-            updateGraph.runWithinUnitTestCycle(() -> {
-                if (modFiltered) {
-                    GenerateTableUpdates.generateShiftAwareTableUpdates(GenerateTableUpdates.DEFAULT_PROFILE,
-                            filteredSize, random, filteredTable, filteredInfo);
-                }
-            });
-            validate(en);
+            if (sourceRefreshing) {
+                updateGraph.runWithinUnitTestCycle(() -> {
+                    if (modFiltered) {
+                        GenerateTableUpdates.generateShiftAwareTableUpdates(GenerateTableUpdates.DEFAULT_PROFILE,
+                                filteredSize, random, filteredTable, filteredInfo);
+                    }
+                });
+                validate(en);
+            }
         }
     }
 
     @Test
-    public void testWhereInDynamicPartialIndexed() {
+    public void testWhereInDynamicPartial() {
+        testWhereInDynamicPartialIndexedInternal(true);
+        testWhereInDynamicPartialIndexedInternal(false);
+    }
+
+    private void testWhereInDynamicPartialIndexedInternal(final boolean setRefreshing) {
         final ColumnInfo<?, ?>[] setInfo;
         final ColumnInfo<?, ?>[] filteredInfo;
 
@@ -471,7 +526,7 @@ public void testWhereInDynamicPartialIndexed() {
         final String[] columnNames =
                 new String[] {"Sym", "intCol", "doubleCol", "charCol", "byteCol", "floatCol", "longCol", "shortCol"};
 
-        final QueryTable setTable = getTable(setSize, random, setInfo = initColumnInfos(
+        final QueryTable setTable = getTable(setRefreshing, setSize, random, setInfo = initColumnInfos(
                 columnNames,
                 new SetGenerator<>("aa", "bb"),
                 new IntGenerator(0, 10),
@@ -495,26 +550,56 @@ public void testWhereInDynamicPartialIndexed() {
 
         DataIndexer.getOrCreateDataIndex(filteredTable, "Sym");
         DataIndexer.getOrCreateDataIndex(filteredTable, "Sym", "charCol");
+        DataIndexer.getOrCreateDataIndex(filteredTable, "Sym", "charCol", "longCol");
+        DataIndexer.getOrCreateDataIndex(filteredTable, "Sym", "charCol", "longCol", "shortCol");
 
         final EvalNugget[] en = new EvalNugget[] {
                 EvalNugget.from(() -> filteredTable.whereIn(setTable, "Sym", "intCol")),
                 EvalNugget.from(() -> filteredTable.whereNotIn(setTable, "Sym", "intCol")),
+
+                EvalNugget.from(() -> filteredTable.whereIn(setTable, "intCol", "Sym")),
+                EvalNugget.from(() -> filteredTable.whereNotIn(setTable, "intCol", "Sym")),
+
                 EvalNugget.from(() -> filteredTable.whereIn(setTable, "Sym", "charCol", "intCol")),
                 EvalNugget.from(() -> filteredTable.whereNotIn(setTable, "Sym", "charCol", "intCol")),
+
+                EvalNugget.from(() -> filteredTable.whereIn(setTable, "intCol", "charCol", "Sym")),
+                EvalNugget.from(() -> filteredTable.whereNotIn(setTable, "intCol", "charCol", "Sym")),
+
+                EvalNugget.from(() -> filteredTable.whereIn(setTable, "Sym", "charCol", "longCol", "byteCol")),
+                EvalNugget.from(() -> filteredTable.whereNotIn(setTable, "Sym", "charCol", "longCol", "byteCol")),
+
+                EvalNugget.from(() -> filteredTable.whereIn(setTable, "charCol", "Sym", "byteCol", "longCol")),
+                EvalNugget.from(() -> filteredTable.whereNotIn(setTable, "charCol", "Sym", "byteCol", "longCol")),
+
+                EvalNugget.from(
+                        () -> filteredTable.whereIn(setTable, "Sym", "charCol", "longCol", "shortCol", "byteCol")),
+                EvalNugget.from(
+                        () -> filteredTable.whereNotIn(setTable, "Sym", "charCol", "longCol", "shortCol", "byteCol")),
+
+                EvalNugget.from(
+                        () -> filteredTable.whereIn(setTable, "charCol", "Sym", "byteCol", "longCol", "shortCol")),
+                EvalNugget.from(
+                        () -> filteredTable.whereNotIn(setTable, "charCol", "Sym", "byteCol", "longCol", "shortCol")),
+
         };
 
+        validate(en);
+
         final ControlledUpdateGraph updateGraph = ExecutionContext.getContext().getUpdateGraph().cast();
         for (int step = 0; step < 100; step++) {
             final boolean modSet = random.nextInt(10) < 1;
             final boolean modFiltered = random.nextBoolean();
 
-            updateGraph.runWithinUnitTestCycle(() -> {
-                if (modSet) {
-                    GenerateTableUpdates.generateShiftAwareTableUpdates(GenerateTableUpdates.DEFAULT_PROFILE,
-                            setSize, random, setTable, setInfo);
-                }
-            });
-            validate(en);
+            if (setRefreshing) {
+                updateGraph.runWithinUnitTestCycle(() -> {
+                    if (modSet) {
+                        GenerateTableUpdates.generateShiftAwareTableUpdates(GenerateTableUpdates.DEFAULT_PROFILE,
+                                setSize, random, setTable, setInfo);
+                    }
+                });
+                validate(en);
+            }
 
             updateGraph.runWithinUnitTestCycle(() -> {
                 if (modFiltered) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/EmptyTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/EmptyTupleSource.java
index df3afce0428..272e4c391c1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/EmptyTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/EmptyTupleSource.java
@@ -43,7 +43,22 @@ public <ELEMENT_TYPE> void exportElement(@NotNull final EmptyTuple tuple, final
     }
 
     @Override
-    public Object exportElement(EmptyTuple tuple, int elementIndex) {
+    public int tupleLength() {
+        return 1;
+    }
+
+    @Override
+    public Object exportElement(@NotNull EmptyTuple tuple, int elementIndex) {
+        throw new UnsupportedOperationException("EmptyTuple does not contain any elements to export");
+    }
+
+    @Override
+    public void exportAllTo(Object @NotNull [] dest, @NotNull EmptyTuple tuple) {
+        throw new UnsupportedOperationException("EmptyTuple does not contain any elements to export");
+    }
+
+    @Override
+    public void exportAllTo(Object @NotNull [] dest, @NotNull EmptyTuple tuple, int @NotNull [] map) {
         throw new UnsupportedOperationException("EmptyTuple does not contain any elements to export");
     }
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/MultiColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/MultiColumnTupleSource.java
index 3a86081cd6d..3881d7f909a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/MultiColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/MultiColumnTupleSource.java
@@ -34,7 +34,7 @@ final class MultiColumnTupleSource implements TupleSource<ArrayTuple>, DefaultCh
     }
 
     @Override
-    public final ArrayTuple createTuple(final long rowKey) {
+    public ArrayTuple createTuple(final long rowKey) {
         final int length = columnSources.length;
         final Object[] columnValues = new Object[length];
         for (int csi = 0; csi < length; ++csi) {
@@ -44,7 +44,7 @@ public final ArrayTuple createTuple(final long rowKey) {
     }
 
     @Override
-    public final ArrayTuple createPreviousTuple(final long rowKey) {
+    public ArrayTuple createPreviousTuple(final long rowKey) {
         final int length = columnSources.length;
         final Object[] columnValues = new Object[length];
         for (int csi = 0; csi < length; ++csi) {
@@ -54,7 +54,7 @@ public final ArrayTuple createPreviousTuple(final long rowKey) {
     }
 
     @Override
-    public final ArrayTuple createTupleFromValues(@NotNull final Object... values) {
+    public ArrayTuple createTupleFromValues(@NotNull final Object... values) {
         final int length = columnSources.length;
         final Object[] valuesCopy = new Object[length];
         System.arraycopy(values, 0, valuesCopy, 0, length);
@@ -62,13 +62,18 @@ public final ArrayTuple createTupleFromValues(@NotNull final Object... values) {
     }
 
     @Override
-    public final <ELEMENT_TYPE> void exportElement(@NotNull final ArrayTuple tuple, final int elementIndex,
+    public int tupleLength() {
+        return columnSources.length;
+    }
+
+    @Override
+    public <ELEMENT_TYPE> void exportElement(@NotNull final ArrayTuple tuple, final int elementIndex,
             @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationIndexKey) {
         writableSource.set(destinationIndexKey, tuple.getElement(elementIndex));
     }
 
     @Override
-    public Object exportElement(ArrayTuple tuple, int elementIndex) {
+    public Object exportElement(@NotNull ArrayTuple tuple, int elementIndex) {
         return tuple.getElement(elementIndex);
     }
 
@@ -177,12 +182,12 @@ public void close() {
     }
 
     @Override
-    public GetContext makeGetContext(int chunkCapacity, SharedContext sharedContext) {
+    public ChunkSource.GetContext makeGetContext(int chunkCapacity, SharedContext sharedContext) {
         return new GetContext(chunkCapacity, columnSources);
     }
 
     @Override
-    public FillContext makeFillContext(int chunkCapacity, SharedContext sharedContext) {
+    public ChunkSource.FillContext makeFillContext(int chunkCapacity, SharedContext sharedContext) {
         return new FillContext(chunkCapacity, columnSources);
     }
 }
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanBooleanColumnTupleSource.java
index 326b8c7891c..4436ec9baf5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanBooleanColumnTupleSource.java
@@ -82,6 +82,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanByteColumnTupleSource.java
index 1d13b44ffca..ad2db06b2a1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanCharacterColumnTupleSource.java
index 75baf07183e..79b7a7b4d76 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanColumnTupleSource.java
index 88b5ac7c101..2f68a466dbd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanColumnTupleSource.java
@@ -75,6 +75,11 @@ public final ByteByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final ByteByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteByteTuple, Boolean, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanDoubleColumnTupleSource.java
index 55884cbf300..8153bbf5682 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanFloatColumnTupleSource.java
index a54415e603f..be73caef7e7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanInstantColumnTupleSource.java
index 643fea75c8c..484068cadcf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanInstantColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanIntegerColumnTupleSource.java
index 8e7c0df66fc..488dda2c347 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanLongColumnTupleSource.java
index d1304cb686a..56e83dca258 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanObjectColumnTupleSource.java
index 1dc93ebc788..d89190d04f9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanObjectColumnTupleSource.java
@@ -82,6 +82,11 @@ public final ByteByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final ByteByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanReinterpretedBooleanColumnTupleSource.java
index 8801a33e873..83cd527e072 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanReinterpretedInstantColumnTupleSource.java
index 45d1e354e44..a7246e53d76 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanShortColumnTupleSource.java
index 1ca9d383843..fa1587df1df 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanBooleanShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteBooleanColumnTupleSource.java
index 43e7d00a02c..34397d59926 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteByteColumnTupleSource.java
index 9649a3dbfd1..5bf38b9c063 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteCharacterColumnTupleSource.java
index 048f256b249..0753a52abb9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteColumnTupleSource.java
index 55c7d1af7dc..330249bbaa1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteByteTuple, Boolean, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteDoubleColumnTupleSource.java
index 429c08fcb3e..efb44c73824 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteFloatColumnTupleSource.java
index 5392bbb9f2c..bf06b965ef4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteInstantColumnTupleSource.java
index 5f981517ac1..f819c70d06c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteIntegerColumnTupleSource.java
index e7c2fd4e6c3..fa5e315160a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteLongColumnTupleSource.java
index 7273765a515..c03d1dcdd79 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteObjectColumnTupleSource.java
index 222b6a27527..8b9bc9fe41b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteReinterpretedBooleanColumnTupleSource.java
index f05fffb7160..2ff27654e11 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteReinterpretedInstantColumnTupleSource.java
index d873775f1f5..8a625d7e297 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteShortColumnTupleSource.java
index 2ec26f10c62..f474c238928 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanByteShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterBooleanColumnTupleSource.java
index f022adf9379..8f705bf1685 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterByteColumnTupleSource.java
index 67e6c37708f..0dfacba0837 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterCharacterColumnTupleSource.java
index 0a96f674e67..754fd30904e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterColumnTupleSource.java
index 476125e085d..378c51e53b8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteCharTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteCharTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteCharTuple, Boolean, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterDoubleColumnTupleSource.java
index 36645a92b5a..fdd79acc1d6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterFloatColumnTupleSource.java
index df695e73682..fb59db1b0ad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterInstantColumnTupleSource.java
index 508b13ac134..32e0cc0aaed 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterIntegerColumnTupleSource.java
index e2ea1432537..6198f593521 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterLongColumnTupleSource.java
index a5a385d680d..d08294ce6b3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterObjectColumnTupleSource.java
index b6438dc5d0b..2597a32b5f2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterReinterpretedBooleanColumnTupleSource.java
index dd56cb13990..45ca5ea98b8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterReinterpretedInstantColumnTupleSource.java
index ccce2a11fa5..06bc6edd82f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterShortColumnTupleSource.java
index e4744d2c64c..57569004672 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanCharacterShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleBooleanColumnTupleSource.java
index 04a8fadada7..ac6459c172a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleByteColumnTupleSource.java
index 7271885b6ff..30cf8a637ae 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleCharacterColumnTupleSource.java
index 1bd9470eea4..fe7b117f794 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleColumnTupleSource.java
index 43b26328283..e402a688bca 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteDoubleTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteDoubleTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteDoubleTuple, Boolean, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleDoubleColumnTupleSource.java
index 5f80f3914ae..565e0fbfa9d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleFloatColumnTupleSource.java
index c210afcd94b..f57c3012493 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleInstantColumnTupleSource.java
index 44356044ffe..43efecf1e86 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleIntegerColumnTupleSource.java
index 5f8d1912117..39397fb6133 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleLongColumnTupleSource.java
index 295067a212a..ff7190ced07 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleObjectColumnTupleSource.java
index 65163b69615..5361feff0a0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleReinterpretedBooleanColumnTupleSource.java
index 23224d49daf..184ec121241 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleReinterpretedInstantColumnTupleSource.java
index 633b93ef9d7..68e748e8941 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleShortColumnTupleSource.java
index 461b5c614e8..b5607eed994 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanDoubleShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatBooleanColumnTupleSource.java
index 8dce92ea0f9..efcbc7b929f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatByteColumnTupleSource.java
index 0aeefc9e695..a71ab67024e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatCharacterColumnTupleSource.java
index 6808e9040e2..d1a8d06519c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatColumnTupleSource.java
index 13a30945de4..9ae24124dfa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteFloatTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteFloatTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteFloatTuple, Boolean, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatDoubleColumnTupleSource.java
index bca3af0d28e..d84d28fb992 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatFloatColumnTupleSource.java
index a6ad076f778..68d69a440d6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatInstantColumnTupleSource.java
index 78bdc5b9832..de16e1b1da1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatIntegerColumnTupleSource.java
index 86876b3ef7c..eafd72e84cc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatLongColumnTupleSource.java
index d4ff4d3c281..872b2143cec 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatObjectColumnTupleSource.java
index 69f10996cec..d53d6a87a96 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatReinterpretedBooleanColumnTupleSource.java
index 910dc6e0ce0..22267f32355 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatReinterpretedInstantColumnTupleSource.java
index 6f7a5e5502a..6b06afcdbf7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatShortColumnTupleSource.java
index 31889142eb8..e9c1f2953b2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanFloatShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantBooleanColumnTupleSource.java
index 58ce0d77cf4..226e7a22363 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantByteColumnTupleSource.java
index e065260287e..0feeec0bf81 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantCharacterColumnTupleSource.java
index 39c9a4ddadc..461e7e6d498 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantColumnTupleSource.java
index 861db37e58e..db5e8be3907 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteLongTuple, Boolean, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantDoubleColumnTupleSource.java
index d070e8512e6..ca4fd4e9ddb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantFloatColumnTupleSource.java
index 6114c14eb7a..6a2d906a9d7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantInstantColumnTupleSource.java
index ca5d27bdbcc..4a731279de4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantInstantColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantIntegerColumnTupleSource.java
index 090972319ee..860331f6c59 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantLongColumnTupleSource.java
index 74df4c6d0ee..d62017d82d1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantObjectColumnTupleSource.java
index 15e7e030b55..91ca0a9101e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantReinterpretedBooleanColumnTupleSource.java
index 3ce17af83fb..6fc5a0cd8a0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantReinterpretedInstantColumnTupleSource.java
index 30e9bd78c33..90608cb1afb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantShortColumnTupleSource.java
index ee43c0f0a43..193f5098531 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerBooleanColumnTupleSource.java
index ede8160d056..cde4e837f3d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerByteColumnTupleSource.java
index 72a89c0399a..d3e2a01ab9f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerCharacterColumnTupleSource.java
index 0ba1595c28d..348e9b15b4e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerColumnTupleSource.java
index 19e33752ef8..99d3d51d5b0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteIntTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteIntTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteIntTuple, Boolean, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerDoubleColumnTupleSource.java
index 87543a60a54..5b9d8cc0cfa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerFloatColumnTupleSource.java
index 0f473c655e3..58869b4ae2c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerInstantColumnTupleSource.java
index 0c166ea1ba8..fadcbf4c7b2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerIntegerColumnTupleSource.java
index 3994f92ef3f..48bb23c1600 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerLongColumnTupleSource.java
index 9b05b1f80d1..05d32a8457a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerObjectColumnTupleSource.java
index 4759b05e795..91d216ffe52 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerReinterpretedBooleanColumnTupleSource.java
index 2508db81fe7..9e785a14974 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerReinterpretedInstantColumnTupleSource.java
index 48c2ce820d7..32265621564 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerShortColumnTupleSource.java
index 10237af12b9..5edd753281d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanIntegerShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongBooleanColumnTupleSource.java
index d2ebb1454c3..785fa4f2242 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongByteColumnTupleSource.java
index 84d3d539ea0..819bb2a7029 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongCharacterColumnTupleSource.java
index 4fb422ca94a..c2c60033c11 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongColumnTupleSource.java
index 355746f220c..dc75f9ae3d6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteLongTuple, Boolean, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongDoubleColumnTupleSource.java
index e96ee1c64ac..3847a092eae 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongFloatColumnTupleSource.java
index 4363dc0d25f..c79ff9a86ee 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongInstantColumnTupleSource.java
index b13aa7c2717..31096a3f225 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongIntegerColumnTupleSource.java
index 74d0d513ef9..5b9ce63b3b5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongLongColumnTupleSource.java
index fdf4708eb0c..7cce5e079cd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongObjectColumnTupleSource.java
index e968b46c7f1..7e8a996cd06 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongReinterpretedBooleanColumnTupleSource.java
index 60af77789b5..63595f8ea6f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongReinterpretedInstantColumnTupleSource.java
index 4339da5c176..15ab4a50306 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongShortColumnTupleSource.java
index 314820b4aaf..ded8cf2e8e9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanLongShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectBooleanColumnTupleSource.java
index 8d2be6d2a19..e67ff28f5ff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectBooleanColumnTupleSource.java
@@ -82,6 +82,11 @@ public final ByteObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final ByteObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectByteColumnTupleSource.java
index 7e7cca54e63..367f539b5d4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectCharacterColumnTupleSource.java
index 32a2eaf9971..93817a78bcf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectColumnTupleSource.java
index e870a80127e..6c3085e3555 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectColumnTupleSource.java
@@ -75,6 +75,11 @@ public final ByteObjectTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final ByteObjectTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteObjectTuple, Boolean, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectDoubleColumnTupleSource.java
index 88857f47a2f..f4803af4735 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectFloatColumnTupleSource.java
index df9fdf2fc27..eadf538a0ff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectInstantColumnTupleSource.java
index 5a53ecf300f..a2106d67d02 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectInstantColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectIntegerColumnTupleSource.java
index 4030db71eef..8e46a6d9cae 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectLongColumnTupleSource.java
index 9608f526dd3..1a669b9053a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectObjectColumnTupleSource.java
index f425a67cea7..a3e2fd736ae 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectObjectColumnTupleSource.java
@@ -82,6 +82,11 @@ public final ByteObjectObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final ByteObjectObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectReinterpretedBooleanColumnTupleSource.java
index aa0cf4db54e..64af2a13398 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectReinterpretedInstantColumnTupleSource.java
index 3a3d29f806a..6868c877dfc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectShortColumnTupleSource.java
index 412bc5e3e47..9aa14aa5bed 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanObjectShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanBooleanColumnTupleSource.java
index 88568b5c450..6f8fef2ef6e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanByteColumnTupleSource.java
index b0c876365bd..b7058ebcce4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanCharacterColumnTupleSource.java
index 2be37a1cd67..0aabaa228ff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanColumnTupleSource.java
index cbd6bae7b14..16ab9471602 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteByteTuple, Boolean, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanDoubleColumnTupleSource.java
index 3bc4ff92bd1..1bb6818fd25 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanFloatColumnTupleSource.java
index 2a3e6662a10..61a9af947c2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanInstantColumnTupleSource.java
index c917457d8d2..2d875c7e07a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanIntegerColumnTupleSource.java
index 4dbb20d015c..64ab098c6a1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanLongColumnTupleSource.java
index 0f9268ca5fb..2e63ee91d1f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanObjectColumnTupleSource.java
index 4cef0f12fc2..9abd9abe306 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 1b083bf7995..1faa0dda365 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 132b21cc2fd..bf6d0026125 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanShortColumnTupleSource.java
index ad739e2ddce..8346d7220a4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantBooleanColumnTupleSource.java
index cb272cb03e8..c9d56e827a5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantByteColumnTupleSource.java
index eb6aaf5db68..0001ffa3443 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantByteColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantCharacterColumnTupleSource.java
index 6b8158b9b56..9136c7befd8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantCharacterColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantColumnTupleSource.java
index ce0e157b306..87e0d890492 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantColumnTupleSource.java
@@ -79,6 +79,11 @@ public final ByteLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -104,6 +109,18 @@ public final Object exportElement(@NotNull final ByteLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -125,6 +142,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteLongTuple, Boolean, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantDoubleColumnTupleSource.java
index b804b93b4ae..94410daba66 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantDoubleColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantFloatColumnTupleSource.java
index 713f1f22793..92505b7cf2e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantFloatColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantInstantColumnTupleSource.java
index f6c38a0fd8d..5934b9a6ced 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantIntegerColumnTupleSource.java
index ee0a9e2847e..4d771c25dce 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantIntegerColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantLongColumnTupleSource.java
index 89f57855a8f..973bdddacaa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantObjectColumnTupleSource.java
index 62aa996378e..c6ad8fa86ad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index 6383152cff5..87c1e060f26 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index 3befaf335a8..75c23536470 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantShortColumnTupleSource.java
index d769316d0fa..adab4ef112d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanReinterpretedInstantShortColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortBooleanColumnTupleSource.java
index 625af2cd3c3..28d15f376c9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortByteColumnTupleSource.java
index 19db6f886ed..2a845648ec7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortCharacterColumnTupleSource.java
index 511d26c2bb3..957962c4687 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortColumnTupleSource.java
index 61897a01295..0f9e6b1c7ac 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteShortTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteShortTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link BooleanShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteShortTuple, Boolean, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortDoubleColumnTupleSource.java
index a15e144739c..6762bd99f83 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortFloatColumnTupleSource.java
index 65034a579e4..3d809d81dc1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortInstantColumnTupleSource.java
index b3a6445c6f2..5dc9560aa61 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortIntegerColumnTupleSource.java
index ee17af520e6..aed0ea49946 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortLongColumnTupleSource.java
index 852b14ab65a..a9b8f4106b1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortObjectColumnTupleSource.java
index 15f626d6221..ac4ee3d2083 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortReinterpretedBooleanColumnTupleSource.java
index 50ed664dece..6a50982f02b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortReinterpretedInstantColumnTupleSource.java
index 276787c1965..7f95c974544 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortShortColumnTupleSource.java
index 715f9223a47..ec8a530e2ec 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/BooleanShortShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanBooleanColumnTupleSource.java
index 8dac6d79706..2be49967fbc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanByteColumnTupleSource.java
index eb2a47b4f32..4ef26e48ea5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanCharacterColumnTupleSource.java
index 2169e1c590c..bc05878f9bf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanColumnTupleSource.java
index 9942d1b9bd9..6dc8e9cdbdc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteByteTuple, Byte, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanDoubleColumnTupleSource.java
index 0b3e48ee866..2bbc0ff5fb9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanFloatColumnTupleSource.java
index de1435decef..03a571242cc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanInstantColumnTupleSource.java
index 5bd9c10d864..99c3b8843df 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanIntegerColumnTupleSource.java
index f45ef578082..cbca35f341e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanLongColumnTupleSource.java
index 0d3483271fe..9a4fefcae1e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanObjectColumnTupleSource.java
index 1109e00168b..1a5b80b095a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanReinterpretedBooleanColumnTupleSource.java
index 6bb0b8ab2ec..4c416def367 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanReinterpretedInstantColumnTupleSource.java
index e4b60ec7760..b81618af633 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanShortColumnTupleSource.java
index d4a1ccadf2e..cecd523c68c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteBooleanColumnTupleSource.java
index de3e69fcb75..a0c8411d92e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteByteColumnTupleSource.java
index 0654ac0c147..95e2483deb0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteByteColumnTupleSource.java
@@ -82,6 +82,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteCharacterColumnTupleSource.java
index 4566082503f..235e0be6a1e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteColumnTupleSource.java
index de002947ea4..49f97abb7cd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteColumnTupleSource.java
@@ -75,6 +75,11 @@ public final ByteByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final ByteByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteByteTuple, Byte, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteDoubleColumnTupleSource.java
index acf99680de1..0f455f60576 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteFloatColumnTupleSource.java
index 023fb4b5934..5f993c5fa9d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteInstantColumnTupleSource.java
index e1f58d5cfe3..47a54091bde 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteIntegerColumnTupleSource.java
index d7b96f8410b..79c1fa3e2b9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteLongColumnTupleSource.java
index f044be98003..1cb681df539 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteObjectColumnTupleSource.java
index 56f0268d92b..ecaf5f50db5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteReinterpretedBooleanColumnTupleSource.java
index eed37fa1bcf..2807a737305 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteReinterpretedBooleanColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteReinterpretedInstantColumnTupleSource.java
index 2ce8e47097e..5196ed78036 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteShortColumnTupleSource.java
index f436e363fa1..021fd65792e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteByteShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterBooleanColumnTupleSource.java
index 38d5392083b..0f192612532 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterByteColumnTupleSource.java
index 13cf8a93426..86b37080aa9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterCharacterColumnTupleSource.java
index 1b5a8c771cf..6334e347367 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteCharCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteCharCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterColumnTupleSource.java
index 85951b399df..99024d234c0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteCharTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteCharTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteCharTuple, Byte, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterDoubleColumnTupleSource.java
index 7d1458e04c1..f7b9c7d63a6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterFloatColumnTupleSource.java
index a026fc83a10..bb6881f8d01 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterInstantColumnTupleSource.java
index 368010d611b..daa60e782a2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterIntegerColumnTupleSource.java
index cd655d31ee9..aa4b824677b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterLongColumnTupleSource.java
index 556a42f5c85..d34acde068b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterObjectColumnTupleSource.java
index f98d81cacca..2d3123f5830 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterReinterpretedBooleanColumnTupleSource.java
index 97acd2f494f..6d8009755be 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterReinterpretedInstantColumnTupleSource.java
index 6fbc0802ed5..f391bee899b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterShortColumnTupleSource.java
index fa4dec7390a..bd9bbf623d2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteCharacterShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleBooleanColumnTupleSource.java
index 6301fa7eead..47ac73c6f20 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleByteColumnTupleSource.java
index d42588ea775..c652e3ba37d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleCharacterColumnTupleSource.java
index 9714084f1fb..182f23f3bf6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleColumnTupleSource.java
index a4eae544b07..ff2ccfae549 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteDoubleTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteDoubleTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteDoubleTuple, Byte, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleDoubleColumnTupleSource.java
index 16a48f7d2f7..15f7342511c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteDoubleDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleFloatColumnTupleSource.java
index 6a84564767a..6b4cc7d5277 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleInstantColumnTupleSource.java
index 0c04f9c1ad2..b54dd358c26 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleIntegerColumnTupleSource.java
index cfa75c5243d..18fc3bc6789 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleLongColumnTupleSource.java
index 7da519e7e81..40e3c266ad1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleObjectColumnTupleSource.java
index b60e339a32a..875f028d673 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleReinterpretedBooleanColumnTupleSource.java
index 8144c70a753..be7578e3840 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleReinterpretedInstantColumnTupleSource.java
index 5e0d095ed4e..ab756a574d8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleShortColumnTupleSource.java
index af0786339b8..2a50107b316 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteDoubleShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatBooleanColumnTupleSource.java
index 101fa427b23..d5c9baeb7c4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatByteColumnTupleSource.java
index 519f7784242..809d6f0814e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatCharacterColumnTupleSource.java
index 32b8f1999fd..56d78343460 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatColumnTupleSource.java
index 86a72e58a7e..9d92ca50e6b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteFloatTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteFloatTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteFloatTuple, Byte, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatDoubleColumnTupleSource.java
index 3e5d548738f..64bd5b70a4e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatFloatColumnTupleSource.java
index 93990ce9cd8..731cb267954 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteFloatFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatInstantColumnTupleSource.java
index 2077c0ef92d..193ce2a7f67 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatIntegerColumnTupleSource.java
index ca0305a7f49..2e1d5355f2f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatLongColumnTupleSource.java
index f2d2ae71d6c..e820a37b226 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatObjectColumnTupleSource.java
index 7d21b81fafc..4fdf59be20c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatReinterpretedBooleanColumnTupleSource.java
index e8f5292fe0c..33740c36698 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatReinterpretedInstantColumnTupleSource.java
index f4abccdf182..630daf0431e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatShortColumnTupleSource.java
index f45f0737b97..b1d866a25a4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteFloatShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantBooleanColumnTupleSource.java
index 22323e3918c..e1cebabe8ad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantByteColumnTupleSource.java
index 8eaf727e851..9346ac5ef7a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantCharacterColumnTupleSource.java
index 91c9b58e92e..979ec66dc39 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantColumnTupleSource.java
index 7d94afc9559..7a6b80b4e90 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final ByteLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final ByteLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteLongTuple, Byte, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantDoubleColumnTupleSource.java
index 20c4f8782cd..ee6d7523e72 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantFloatColumnTupleSource.java
index 64ebd069698..5140cbf7e3a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantInstantColumnTupleSource.java
index 9c0a1a9e71c..0f48459203a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantIntegerColumnTupleSource.java
index bae785e7bcc..b54bf260678 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantLongColumnTupleSource.java
index efafc5fc785..0d3534d8569 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantObjectColumnTupleSource.java
index c9d3afc35d8..b8f4420655d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantReinterpretedBooleanColumnTupleSource.java
index 47da07abd7e..e1f3b1c2a9f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantReinterpretedInstantColumnTupleSource.java
index 259669feaca..85ea63ac62e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantShortColumnTupleSource.java
index c95c67621f9..ca632f7c0b2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerBooleanColumnTupleSource.java
index 838d21f54a9..413390373f4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerByteColumnTupleSource.java
index 8bd7a56a33e..f5f8551e0c9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerCharacterColumnTupleSource.java
index 31cf2c27370..570c32e3272 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerColumnTupleSource.java
index 681c2d32fd8..8385d5f0fb3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteIntTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteIntTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteIntTuple, Byte, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerDoubleColumnTupleSource.java
index 76b34685eaf..39f4ea3b30e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerFloatColumnTupleSource.java
index 3e4166ba6e9..0a866b418d4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerInstantColumnTupleSource.java
index 603f0b93039..b1595a5f7df 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerIntegerColumnTupleSource.java
index 8447f99726e..38304d1de90 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteIntIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteIntIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerLongColumnTupleSource.java
index c08cf52318a..7561bc3edbc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerObjectColumnTupleSource.java
index 0babf1d427f..963ad3d68d1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerReinterpretedBooleanColumnTupleSource.java
index 6b3514638d6..fdb67b7bd20 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerReinterpretedInstantColumnTupleSource.java
index 7c29b7b018b..5f2b309c712 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerShortColumnTupleSource.java
index cbf9513fe68..f1d17c54a90 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteIntegerShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongBooleanColumnTupleSource.java
index 9a7cf05720e..8d8165c05e3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongByteColumnTupleSource.java
index 2a033c55721..3d12fd3545f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongCharacterColumnTupleSource.java
index ac1ec01b147..6b97b0b75a7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongColumnTupleSource.java
index 75e77faaa7e..9fa1ded29d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteLongTuple, Byte, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongDoubleColumnTupleSource.java
index edc944943a5..3b02c449124 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongFloatColumnTupleSource.java
index e2926665f70..8521d536ad1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongInstantColumnTupleSource.java
index 394546ce477..ce9e89c9f13 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongIntegerColumnTupleSource.java
index beaa7fe083e..6b09ac12aae 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongLongColumnTupleSource.java
index 9368772da15..0a3e2f808a3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongObjectColumnTupleSource.java
index 36f3e6c5b9c..2ea96ab9404 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongReinterpretedBooleanColumnTupleSource.java
index cc5eb9ef6c9..dd753210336 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongReinterpretedInstantColumnTupleSource.java
index a8209827585..18c1a84f361 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongShortColumnTupleSource.java
index e83f5c4bef3..426252506a0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteLongShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectBooleanColumnTupleSource.java
index 4f2f57d27d7..e4e56b8b0f9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectByteColumnTupleSource.java
index 5958a034504..d86d2b55275 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectCharacterColumnTupleSource.java
index 3a5ce581aee..0ba20fae8de 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectColumnTupleSource.java
index afcd8d891d7..25a6b292d05 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteObjectTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteObjectTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteObjectTuple, Byte, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectDoubleColumnTupleSource.java
index bd4505f3239..60b50e1d31e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectFloatColumnTupleSource.java
index 56c16833b0e..14b16688fd5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectInstantColumnTupleSource.java
index b131643fc27..6cd8cd70c91 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectIntegerColumnTupleSource.java
index 996e3e6567a..1d742333e4c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectLongColumnTupleSource.java
index d6623dcc4cf..22acd8c5eb8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectObjectColumnTupleSource.java
index eb19d3229be..826b5a6b483 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteObjectObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteObjectObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectReinterpretedBooleanColumnTupleSource.java
index 847e05c608b..a843ef48114 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectReinterpretedInstantColumnTupleSource.java
index a04fd62560f..f418da99c7b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectShortColumnTupleSource.java
index 93e54f9dd89..674225a4fa8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteObjectShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanBooleanColumnTupleSource.java
index e58a2d256ad..9136d77a9b0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanByteColumnTupleSource.java
index 00b046542ac..6d44ac3735d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanCharacterColumnTupleSource.java
index 359476ab5d9..5320bdf2955 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanColumnTupleSource.java
index 68be0e220d3..4aa57f33c39 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteByteTuple, Byte, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanDoubleColumnTupleSource.java
index c86eeca9f47..6b01bfec812 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanFloatColumnTupleSource.java
index a353a04d5c3..dcf7eec1a14 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanInstantColumnTupleSource.java
index d58221726a9..d82d45ba228 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanIntegerColumnTupleSource.java
index 1bc15780bf6..9f6fc5eda6f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanLongColumnTupleSource.java
index c10d17f6b4b..d4cab53ce33 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanObjectColumnTupleSource.java
index 0e5f0e56331..2bcea80b1a0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index d27791af90b..528a65c7911 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 8da6dbd8d2c..165db61d618 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanShortColumnTupleSource.java
index 3b86cf90f36..0194165bbc1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedBooleanShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantBooleanColumnTupleSource.java
index a96acd3bc2e..7bd37608652 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantByteColumnTupleSource.java
index c8be1d4becd..4068220bf53 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantCharacterColumnTupleSource.java
index 0bf848e1284..71f95aeaca9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantColumnTupleSource.java
index 3545a42c924..d70c99bddab 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final ByteLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final ByteLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteLongTuple, Byte, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantDoubleColumnTupleSource.java
index 00fc06e178c..358d69e8b4e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantFloatColumnTupleSource.java
index e456578e430..414af1dc393 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantInstantColumnTupleSource.java
index ddd9653fef8..1748f01d324 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantIntegerColumnTupleSource.java
index b3e770a35f4..393fac6e9ef 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantLongColumnTupleSource.java
index ad6f9ce9468..06bd39dac85 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantObjectColumnTupleSource.java
index e50bdb1c6e9..c591f9f14cd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index 512aa72e658..f09ce17d576 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index 688f06a4387..79ae9e646ba 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantShortColumnTupleSource.java
index c755567a001..28ce135e643 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteReinterpretedInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortBooleanColumnTupleSource.java
index 739959279e2..f146a078c9b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortByteColumnTupleSource.java
index 97464513886..1be3f536d56 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortCharacterColumnTupleSource.java
index 585c6b5c073..333266db9b4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortColumnTupleSource.java
index bf840be5e36..88b2d09c315 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteShortTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteShortTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ByteShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteShortTuple, Byte, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortDoubleColumnTupleSource.java
index a7e315c0c70..c522810e537 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortFloatColumnTupleSource.java
index 47df743af8c..881462f1f5e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortInstantColumnTupleSource.java
index f12996999a2..931c9d36ef9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortIntegerColumnTupleSource.java
index 14e45f9dd51..f7c9f251eea 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortLongColumnTupleSource.java
index 95d653f85de..929cb7a9e6f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortObjectColumnTupleSource.java
index 68cc7cb69c2..87ad37b1cb5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortReinterpretedBooleanColumnTupleSource.java
index 1e4c0c9a397..8d1b555db9a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortReinterpretedInstantColumnTupleSource.java
index 9069ef10b00..6447a5ed05f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortShortColumnTupleSource.java
index 62128e74c56..f785ff3f133 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ByteShortShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteShortShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteShortShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanBooleanColumnTupleSource.java
index c40c3d10019..6c4b513db0c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanByteColumnTupleSource.java
index c1edff48131..d042c2be1b9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanCharacterColumnTupleSource.java
index 681f87ce591..fc68d954c6f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanColumnTupleSource.java
index 54b3b71d3c0..65dd759a862 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final CharByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final CharByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharByteTuple, Character, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanDoubleColumnTupleSource.java
index 28837e22f79..176daf01367 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanFloatColumnTupleSource.java
index b8992cc9f46..09277393ffd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanInstantColumnTupleSource.java
index a5dd7190beb..7f467b64757 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanIntegerColumnTupleSource.java
index 9eff3916f3e..73785c7d3c9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanLongColumnTupleSource.java
index 771e13da00d..94bef92b739 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanObjectColumnTupleSource.java
index 103bca0ae4e..08096d19c16 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanReinterpretedBooleanColumnTupleSource.java
index 780b6993974..7796852e17d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanReinterpretedInstantColumnTupleSource.java
index bb39792ae43..455f8c5091b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final CharByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final CharByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanShortColumnTupleSource.java
index 1ab486ab05b..285be48368d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteBooleanColumnTupleSource.java
index 1e4b9a81b16..5e078b1b894 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteByteColumnTupleSource.java
index 9a04c85ee8f..5a6e515ddfc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteCharacterColumnTupleSource.java
index 435c615daca..fcb42adc42b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteColumnTupleSource.java
index cc23d293af9..08f7f17a4ce 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteColumnTupleSource.java
@@ -76,6 +76,11 @@ public final CharByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final CharByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharByteTuple, Character, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteDoubleColumnTupleSource.java
index 64f0f23f96d..41b0d381af2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteFloatColumnTupleSource.java
index 46b24f2599c..8120c51296c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteInstantColumnTupleSource.java
index a1ae12e2569..939a491f318 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteIntegerColumnTupleSource.java
index a69842ec81e..6ffa2af24ef 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteLongColumnTupleSource.java
index a1dc91267ce..a732f4382ab 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteObjectColumnTupleSource.java
index 6087d1ed953..afd84b61e62 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteReinterpretedBooleanColumnTupleSource.java
index 65bafcdf932..6a8eff00418 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteReinterpretedInstantColumnTupleSource.java
index f4ac48ce7fd..6b83d4c9e90 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteShortColumnTupleSource.java
index 9f00e97f060..b31d37b3db7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterByteShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterBooleanColumnTupleSource.java
index eb29f6081c6..e4763353359 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterByteColumnTupleSource.java
index ff6481b5446..36c97d8de57 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterCharacterColumnTupleSource.java
index 83c594f0a59..113986c7284 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterCharacterColumnTupleSource.java
@@ -82,6 +82,11 @@ public final CharCharCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final CharCharCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterColumnTupleSource.java
index 20714b68c37..f75a203a427 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterColumnTupleSource.java
@@ -75,6 +75,11 @@ public final CharCharTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final CharCharTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharCharTuple, Character, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterDoubleColumnTupleSource.java
index e5fbeac86dc..78a4f6132ef 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharCharDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterFloatColumnTupleSource.java
index c55a3f15482..c71648f04f1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharCharFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharCharFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterInstantColumnTupleSource.java
index 7f7031fee51..14d26e1b3a3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterIntegerColumnTupleSource.java
index dd87303dd29..a09bf59e196 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharCharIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharCharIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterLongColumnTupleSource.java
index 85a1dae5ed0..389e7360be1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterObjectColumnTupleSource.java
index 8824c92bd19..be236bfc361 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharCharObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharCharObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterReinterpretedBooleanColumnTupleSource.java
index 57d7a12f77e..9b53ed98c9a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterReinterpretedInstantColumnTupleSource.java
index 1fb04842b18..9b12f6bed66 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterShortColumnTupleSource.java
index 1ac3176e356..12218ba8e47 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterCharacterShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharCharShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharCharShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharCharShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleBooleanColumnTupleSource.java
index 31cd64dd9bc..0a4bef73d1e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleByteColumnTupleSource.java
index f65fff4bc0a..a5891f05356 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleCharacterColumnTupleSource.java
index 4e2cbe250f0..29dabc2a352 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharDoubleCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleColumnTupleSource.java
index a42f94100d6..56311628173 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleColumnTupleSource.java
@@ -76,6 +76,11 @@ public final CharDoubleTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final CharDoubleTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharDoubleTuple, Character, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleDoubleColumnTupleSource.java
index 384ffaa0ab7..a53aa44b89d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharDoubleDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleFloatColumnTupleSource.java
index 557eadffb1d..3f1165d7a8b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharDoubleFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleInstantColumnTupleSource.java
index 73bde32a578..19c0284476f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleIntegerColumnTupleSource.java
index 881bd1ddb6f..2754c087a7e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharDoubleIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleLongColumnTupleSource.java
index b45f65e5e37..8f3555faea5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleObjectColumnTupleSource.java
index 0ab2daf59b4..d8691d764b5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharDoubleObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleReinterpretedBooleanColumnTupleSource.java
index 4baec49015c..ea6ad474937 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleReinterpretedInstantColumnTupleSource.java
index b19559061f2..30f19a406fe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleShortColumnTupleSource.java
index 7f914b9639c..36fb6447d69 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterDoubleShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharDoubleShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharDoubleShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharDoubleShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatBooleanColumnTupleSource.java
index 5c4e9313361..bf5eb74bf55 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatByteColumnTupleSource.java
index 464ec811638..db310a8c94b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatCharacterColumnTupleSource.java
index 080ecb8c89b..385500c2a75 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharFloatCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharFloatCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatColumnTupleSource.java
index 83a11cbb2a7..0c26bb4da5a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatColumnTupleSource.java
@@ -76,6 +76,11 @@ public final CharFloatTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final CharFloatTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharFloatTuple, Character, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatDoubleColumnTupleSource.java
index 64b42ee6f75..4bfe752d543 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharFloatDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatFloatColumnTupleSource.java
index 392487ff49d..d6d7a415833 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharFloatFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatInstantColumnTupleSource.java
index 5cd70ed159c..b1ece0fb8db 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatIntegerColumnTupleSource.java
index d3848bc2047..7e3de9f5edb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharFloatIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharFloatIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatLongColumnTupleSource.java
index 638c8827ffd..47dde120c61 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatObjectColumnTupleSource.java
index 6dcdf410863..202fc964a26 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharFloatObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharFloatObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatReinterpretedBooleanColumnTupleSource.java
index 075437d56e9..cfd07fd9aac 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatReinterpretedInstantColumnTupleSource.java
index 4bc81f82441..b540f4f2af8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatShortColumnTupleSource.java
index 8eefd8324f7..8a63ffdbfde 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterFloatShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharFloatShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharFloatShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharFloatShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantBooleanColumnTupleSource.java
index 684bc545d27..db1adfa9b56 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantByteColumnTupleSource.java
index 6ffcb8ecb54..f208426e132 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantCharacterColumnTupleSource.java
index 7549e0340ed..3e0cb995c45 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantColumnTupleSource.java
index 9860715e5a4..b9a8a86e8db 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final CharLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final CharLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharLongTuple, Character, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantDoubleColumnTupleSource.java
index 60d276f7692..f1ab6387230 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantFloatColumnTupleSource.java
index 94f16b2e025..5fdf77d5ee7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantInstantColumnTupleSource.java
index d5864eb7d1c..27e82afc82e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantIntegerColumnTupleSource.java
index 71de7e769f6..22a846e38c4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantLongColumnTupleSource.java
index e84cb936407..8d36a35cdc2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantObjectColumnTupleSource.java
index 4ec0e65c4ea..b56de8e5509 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantReinterpretedBooleanColumnTupleSource.java
index 1cc3527e452..4374a67920f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final CharLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final CharLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantReinterpretedInstantColumnTupleSource.java
index 3c87839afb2..e188f37f83a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantShortColumnTupleSource.java
index 644a6f48708..aa01212f5d7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerBooleanColumnTupleSource.java
index 3c36d5738d5..4073a91fa46 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerByteColumnTupleSource.java
index a63c939981c..2a72dfbd012 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerCharacterColumnTupleSource.java
index 6ff183327a5..a5596fbc4c1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharIntCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharIntCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerColumnTupleSource.java
index 5c7d60dee39..e6238a9431f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerColumnTupleSource.java
@@ -76,6 +76,11 @@ public final CharIntTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final CharIntTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharIntTuple, Character, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerDoubleColumnTupleSource.java
index 94492193444..4c8795b99e4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharIntDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerFloatColumnTupleSource.java
index 0b53d7a4c10..db12ca379f7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharIntFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharIntFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerInstantColumnTupleSource.java
index a9d5d709882..24bea0b1d23 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerIntegerColumnTupleSource.java
index de3a93a9d1f..46d54ce426f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharIntIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharIntIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerLongColumnTupleSource.java
index ca5ada5bd3e..efc35e26928 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerObjectColumnTupleSource.java
index 5818cee7cb6..f1bf8f2e72a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharIntObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharIntObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerReinterpretedBooleanColumnTupleSource.java
index cb27f59709c..f7b8f206b9f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerReinterpretedInstantColumnTupleSource.java
index 01d91befaab..5616c9b6282 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerShortColumnTupleSource.java
index ccd78f19686..45bb52cbc29 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterIntegerShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharIntShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharIntShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharIntShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongBooleanColumnTupleSource.java
index 7de5a6c0014..3d5266aebe7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongByteColumnTupleSource.java
index 71b02c6bf9a..b624aadf125 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongCharacterColumnTupleSource.java
index cea6a9b7c3b..c2e722d3c9e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongColumnTupleSource.java
index e42b8f93106..57d4e66f42a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongColumnTupleSource.java
@@ -76,6 +76,11 @@ public final CharLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final CharLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharLongTuple, Character, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongDoubleColumnTupleSource.java
index 2c5ca171a02..d02bba7c79f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongFloatColumnTupleSource.java
index bc9117165a1..e0c09630e5b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongInstantColumnTupleSource.java
index fd7021c3062..82866891548 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongIntegerColumnTupleSource.java
index c11e10757cb..4892a7b8429 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongLongColumnTupleSource.java
index 4dcd582cff8..4fc79a16904 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongObjectColumnTupleSource.java
index c26033174e3..0ec375694ca 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongReinterpretedBooleanColumnTupleSource.java
index bef3ce22790..dd7f91052d5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongReinterpretedInstantColumnTupleSource.java
index bbd2d158f62..0f3647674ad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongShortColumnTupleSource.java
index cec98a83980..b285e08989b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterLongShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectBooleanColumnTupleSource.java
index 414aa7c1df1..99bec0c1843 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectByteColumnTupleSource.java
index 4faac428c9c..34c9f49db5f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectCharacterColumnTupleSource.java
index 749ab09fbb6..b9a797a6429 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharObjectCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharObjectCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectColumnTupleSource.java
index 011bca48078..810fe020480 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectColumnTupleSource.java
@@ -76,6 +76,11 @@ public final CharObjectTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final CharObjectTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharObjectTuple, Character, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectDoubleColumnTupleSource.java
index 2ddce560c2f..d72ac6c15ea 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharObjectDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectFloatColumnTupleSource.java
index 5e72d6b5e39..dafcd6726fa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharObjectFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharObjectFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectInstantColumnTupleSource.java
index cc5639c16c5..a4d3ec93bae 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectIntegerColumnTupleSource.java
index 89ed456bb91..829739d359d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharObjectIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharObjectIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectLongColumnTupleSource.java
index 5a07412849a..91cce1e5df6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectObjectColumnTupleSource.java
index 5fb7415d4cd..a3c176cdca5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharObjectObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharObjectObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectReinterpretedBooleanColumnTupleSource.java
index e9a4ed56cff..dfad476b890 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectReinterpretedInstantColumnTupleSource.java
index b6366a94c22..0a8ed3850f3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectShortColumnTupleSource.java
index 37040ad1fad..3ddc4880e99 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterObjectShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharObjectShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharObjectShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharObjectShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanBooleanColumnTupleSource.java
index 6ae8e64e741..d212476377f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanByteColumnTupleSource.java
index 4de4fbe6f67..9728f7a33f3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanCharacterColumnTupleSource.java
index 8bc730df086..b1cc0048ded 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanColumnTupleSource.java
index 085c0609a71..ea550b7105a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final CharByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final CharByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharByteTuple, Character, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanDoubleColumnTupleSource.java
index 984ef761b0c..c31c83cec25 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanFloatColumnTupleSource.java
index f2eeb91f06f..b0411c60e90 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanInstantColumnTupleSource.java
index f18893e61ed..faae12f3cec 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final CharByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final CharByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanIntegerColumnTupleSource.java
index a0e1701cebd..a6a2fe57f8d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanLongColumnTupleSource.java
index 0dcfd17d234..e2d12a84bc6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanObjectColumnTupleSource.java
index efb1a327ed9..1b862626422 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 5ca0b161ec8..27b45878d20 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 3e21a546ffd..69904273b25 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final CharByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final CharByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanShortColumnTupleSource.java
index 5614e53f89e..20959facd27 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantBooleanColumnTupleSource.java
index 4ba2ec0ce3b..0a3fa1aea1e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final CharLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final CharLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantByteColumnTupleSource.java
index f1fc41d5b86..a720c33af9b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantCharacterColumnTupleSource.java
index 6df782643f9..6f02803bb89 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantColumnTupleSource.java
index 6db0b2cfea8..bd1c72fdcfb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final CharLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final CharLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharLongTuple, Character, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantDoubleColumnTupleSource.java
index 6905870d473..fd93e59cce8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantFloatColumnTupleSource.java
index d316d186a3d..d54048c5ba7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantInstantColumnTupleSource.java
index b1fed4fce93..edfb775e35e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantIntegerColumnTupleSource.java
index ae5caa30209..a53643ae6c8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantLongColumnTupleSource.java
index e441b5768d1..f136e6c3ade 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantObjectColumnTupleSource.java
index 6f2d03576b5..d3b26caae0e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index 2f95965b5b6..ca4d2a56dfe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final CharLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final CharLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index 01d1346ed1b..f56fd77a607 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantShortColumnTupleSource.java
index b2572de0a66..ba4ed2e4044 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterReinterpretedInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortBooleanColumnTupleSource.java
index 16f3e0c62ea..0bbd601f81b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortByteColumnTupleSource.java
index b07ace042e3..565caa6dd95 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortCharacterColumnTupleSource.java
index b6f074913a4..167e6ba29e1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharShortCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharShortCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortColumnTupleSource.java
index 4c65586eb98..26c65d8b70c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortColumnTupleSource.java
@@ -76,6 +76,11 @@ public final CharShortTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final CharShortTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link CharacterShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<CharShortTuple, Character, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortDoubleColumnTupleSource.java
index 4089c347cc5..686dcf82748 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharShortDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharShortDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortFloatColumnTupleSource.java
index 01e1b322cbf..7466d345e44 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharShortFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharShortFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortInstantColumnTupleSource.java
index 2ad8dd8f25e..3909e18b8fb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortIntegerColumnTupleSource.java
index 028ab0418e7..3e25f1b9f25 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharShortIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharShortIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortLongColumnTupleSource.java
index bf6570a88b7..1ab0511975e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortObjectColumnTupleSource.java
index b19fb786a4c..a3db7cdc663 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final CharShortObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final CharShortObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortReinterpretedBooleanColumnTupleSource.java
index 17607f6c997..c8275bd0f14 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final CharShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final CharShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortReinterpretedInstantColumnTupleSource.java
index 28e4235e006..ccf9a7d2cab 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final CharShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final CharShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortShortColumnTupleSource.java
index fbbe0a32c06..fa2b916ead0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/CharacterShortShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final CharShortShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final CharShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final CharShortShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final CharShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final CharShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final CharShortShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final CharShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanBooleanColumnTupleSource.java
index 40fa76669c6..75fad96279a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanByteColumnTupleSource.java
index 4b8372447dc..b6a9e5341ab 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanCharacterColumnTupleSource.java
index 1f2f15eff81..3bd29fab5af 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanColumnTupleSource.java
index f3482d6fb6b..2c1576786fb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final DoubleByteTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final DoubleByteTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleByteTuple, Double, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanDoubleColumnTupleSource.java
index 30105212441..19fd6441333 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanFloatColumnTupleSource.java
index 64554858de3..52364638a7c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanInstantColumnTupleSource.java
index d99a12ecbf4..a992bf5ba5e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanIntegerColumnTupleSource.java
index 571b10b8ba4..d3bc972bb9e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanLongColumnTupleSource.java
index 80c22c3d36d..d88424369b7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanObjectColumnTupleSource.java
index 4d4dd7ca5a7..8d453d1c437 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanReinterpretedBooleanColumnTupleSource.java
index 9e23e59ce30..a0d0b92dca5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanReinterpretedInstantColumnTupleSource.java
index 3afd12d83b8..f80f3c1c469 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final DoubleByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final DoubleByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanShortColumnTupleSource.java
index f049e8090b5..10e399c40fd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteBooleanColumnTupleSource.java
index 3609faddefd..76fd8117f9f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteByteColumnTupleSource.java
index 024671b30e1..7f0be1160b2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteCharacterColumnTupleSource.java
index b431d5b0b39..ded0a521b1b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteColumnTupleSource.java
index a8a5c675722..46247d944a4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteColumnTupleSource.java
@@ -76,6 +76,11 @@ public final DoubleByteTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final DoubleByteTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleByteTuple, Double, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteDoubleColumnTupleSource.java
index d09121ee313..93247388403 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleByteDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleByteDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteFloatColumnTupleSource.java
index 244e876b616..7be62e15e8c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteInstantColumnTupleSource.java
index af79ae0a7b9..af8502e2a95 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteIntegerColumnTupleSource.java
index 0e28b5fbe4c..9dfb83c0f1c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteLongColumnTupleSource.java
index 9d8d241d38e..59a858af28a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteObjectColumnTupleSource.java
index ed25e476db6..93f124d41cf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteReinterpretedBooleanColumnTupleSource.java
index b03348f58d6..f231f7ea52c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteReinterpretedInstantColumnTupleSource.java
index 108e5c171f9..dcf80b6ffe7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteShortColumnTupleSource.java
index df5b217ed7c..ffa7359be3f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleByteShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterBooleanColumnTupleSource.java
index a80d0ff1353..49f6095aec8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleCharByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleCharByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterByteColumnTupleSource.java
index c05b54177c2..360c1fda6db 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleCharByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleCharByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterCharacterColumnTupleSource.java
index 600ee220cfe..3d221c8da53 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleCharCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleCharCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterColumnTupleSource.java
index 6e20690378f..1156470b5ff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterColumnTupleSource.java
@@ -76,6 +76,11 @@ public final DoubleCharTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final DoubleCharTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleCharTuple, Double, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterDoubleColumnTupleSource.java
index 8afff3a3b5a..efb415364c8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleCharDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleCharDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterFloatColumnTupleSource.java
index 419537c3236..e7882cb208f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleCharFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleCharFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterInstantColumnTupleSource.java
index 7e4f4dfe3d3..b7e7d5aa5b9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleCharLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleCharLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterIntegerColumnTupleSource.java
index 574c77563d7..8ffd8b7737e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleCharIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleCharIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterLongColumnTupleSource.java
index 11e6c368824..bc688d3e58f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleCharLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleCharLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterObjectColumnTupleSource.java
index 06e2492db7c..a0022198c65 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleCharObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleCharObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterReinterpretedBooleanColumnTupleSource.java
index 82464c936ca..84bcc46819a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleCharByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleCharByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterReinterpretedInstantColumnTupleSource.java
index f079b88eed2..d3419beab52 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleCharLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleCharLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterShortColumnTupleSource.java
index f5b9b5f6847..b1e4b8a30d0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleCharacterShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleCharShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleCharShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleCharShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleBooleanColumnTupleSource.java
index a3bf9d8e22f..d5c532a4d99 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleDoubleByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleDoubleByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleByteColumnTupleSource.java
index a3b885df432..a17bca2bb37 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleDoubleByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleDoubleByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleCharacterColumnTupleSource.java
index 3e4fbd25484..92104b9c3f6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleDoubleCharTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleDoubleCharTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleCharTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleColumnTupleSource.java
index e40626a707d..526b335410d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleColumnTupleSource.java
@@ -75,6 +75,11 @@ public final DoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final DoubleDoubleTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleDoubleTuple, Double, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleDoubleColumnTupleSource.java
index 2eab9530fcd..6d1a0a498d6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleDoubleColumnTupleSource.java
@@ -82,6 +82,11 @@ public final DoubleDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final DoubleDoubleDoubleTuple tuple,
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleDouble
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleFloatColumnTupleSource.java
index fad0ba3ec21..570ae11eee2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleDoubleFloatTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleFloatT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleInstantColumnTupleSource.java
index 7085e0f278d..9aad3a778d5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleDoubleLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleDoubleLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleIntegerColumnTupleSource.java
index d7ad3d62192..e28b4208133 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleDoubleIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleIntTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleLongColumnTupleSource.java
index 43dc682c39b..58b6cbc164b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleDoubleLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleDoubleLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleObjectColumnTupleSource.java
index aaf1fc866c9..ae47a3d0c6b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleDoubleObjectTuple tuple,
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleObject
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleReinterpretedBooleanColumnTupleSource.java
index 9441f9a07c4..11f7eb0b0af 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleDoubleByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleDoubleByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleReinterpretedInstantColumnTupleSource.java
index f1fd676dfb6..99cb2c6a386 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleDoubleLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleDoubleLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleShortColumnTupleSource.java
index 9ae96cabcec..ab5a0cb579c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleDoubleShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleDoubleShortTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleDoubleShortTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleDoubleShortT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatBooleanColumnTupleSource.java
index 43742d54bbb..92a3c662746 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleFloatByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatByteColumnTupleSource.java
index d9f261f4ad1..3a2d6c516f4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleFloatByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatCharacterColumnTupleSource.java
index f5110d0d4bf..fe7d9971788 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleFloatCharTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleFloatCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatCharTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatColumnTupleSource.java
index 0cbbd656391..81da0e49b0c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatColumnTupleSource.java
@@ -76,6 +76,11 @@ public final DoubleFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final DoubleFloatTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleFloatTuple, Double, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatDoubleColumnTupleSource.java
index 2c55d4e979f..ccc23fac375 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleFloatDoubleTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatDoubleT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatFloatColumnTupleSource.java
index 88a5e8ad5e8..8b4f507717b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleFloatFloatTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleFloatFloatTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatFloatTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatInstantColumnTupleSource.java
index 32de31e64cd..f19901cae8e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleFloatLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatIntegerColumnTupleSource.java
index 1a71b63a9f1..d26b0ec9f97 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleFloatIntTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleFloatIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatIntTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatLongColumnTupleSource.java
index 317d24c1732..2a30c2a449a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleFloatLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatObjectColumnTupleSource.java
index cc7ef245a69..87e16cc1958 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleFloatObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleFloatObjectTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatObjectT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatReinterpretedBooleanColumnTupleSource.java
index e7508d57848..760b451c1b5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleFloatByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatReinterpretedInstantColumnTupleSource.java
index 8cf81c853ed..174cd0905e8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleFloatLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatShortColumnTupleSource.java
index 700c6b22406..c35bce0b2a5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleFloatShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleFloatShortTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleFloatShortTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleFloatShortTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantBooleanColumnTupleSource.java
index bb344d231a2..219e9bd8281 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantByteColumnTupleSource.java
index e05f2653c32..a730b1381fa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantCharacterColumnTupleSource.java
index 50c18d1ea41..ef5be0a465f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantColumnTupleSource.java
index f35bb03ab24..b2a5664f2d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final DoubleLongTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final DoubleLongTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleLongTuple, Double, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantDoubleColumnTupleSource.java
index f597f785f2b..bd30c7108c5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleLongDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleLongDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantFloatColumnTupleSource.java
index c114d16e4f9..e8b9ba2399d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantInstantColumnTupleSource.java
index a48e9e5e629..b76070ca562 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantIntegerColumnTupleSource.java
index 05e137c7ea0..e45b8f16b8c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantLongColumnTupleSource.java
index d5237ffab5f..b1db77c6194 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantObjectColumnTupleSource.java
index f31fd4a8280..b752de739ae 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleLongObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleLongObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantReinterpretedBooleanColumnTupleSource.java
index a14385033c0..169c908d049 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final DoubleLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final DoubleLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantReinterpretedInstantColumnTupleSource.java
index fd419010bc6..1c117cd4ce1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantShortColumnTupleSource.java
index e53709b4c21..52110ecba9e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerBooleanColumnTupleSource.java
index 242c48c2d83..0494fee589b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleIntByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleIntByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerByteColumnTupleSource.java
index b0be33190d8..6ed77c550cb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleIntByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleIntByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerCharacterColumnTupleSource.java
index adc34a40e0c..355c7de2f52 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleIntCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleIntCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerColumnTupleSource.java
index 43c7398b9ed..41e90554d27 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerColumnTupleSource.java
@@ -76,6 +76,11 @@ public final DoubleIntTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final DoubleIntTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleIntTuple, Double, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerDoubleColumnTupleSource.java
index e4990c6271c..8a55279a20f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleIntDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerFloatColumnTupleSource.java
index f81c6a5f0cc..dd17bc9b04e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleIntFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleIntFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerInstantColumnTupleSource.java
index 7845c9756ca..a48b8fc3b8c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleIntLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleIntLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerIntegerColumnTupleSource.java
index 24c69c0f001..2d318e62c47 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleIntIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleIntIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerLongColumnTupleSource.java
index bbfe4c4fda5..57a012a5625 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleIntLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleIntLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerObjectColumnTupleSource.java
index 7a5a34178df..7732eea5542 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleIntObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleIntObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerReinterpretedBooleanColumnTupleSource.java
index c0d6509b407..22f3084a9a1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleIntByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleIntByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerReinterpretedInstantColumnTupleSource.java
index 35c716baf36..0f8d17f480f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleIntLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleIntLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerShortColumnTupleSource.java
index 21a377368dd..186477d0481 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleIntegerShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleIntShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleIntShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleIntShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongBooleanColumnTupleSource.java
index f22a4ec5b85..7de1c82604f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongByteColumnTupleSource.java
index 11608abafa3..8738731bf8d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongCharacterColumnTupleSource.java
index ef4e3cf7b66..0f6644aa47a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleLongCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleLongCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongColumnTupleSource.java
index d4f57d705d3..dbb8832b89c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongColumnTupleSource.java
@@ -76,6 +76,11 @@ public final DoubleLongTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final DoubleLongTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleLongTuple, Double, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongDoubleColumnTupleSource.java
index 1c5f6dcf6d8..1baa7679e36 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleLongDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleLongDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongFloatColumnTupleSource.java
index 4d66c2fb374..b062f56b5cf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleLongFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongInstantColumnTupleSource.java
index f001f17a403..e505c158570 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongIntegerColumnTupleSource.java
index 144a24dafb1..c3d4385316c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleLongIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleLongIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongLongColumnTupleSource.java
index 1ae0dfce8cb..439fb12d8a6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongObjectColumnTupleSource.java
index 8af1913d8fe..b5ba165f530 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleLongObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleLongObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongReinterpretedBooleanColumnTupleSource.java
index 99d81157c8d..4cdaa0bd6cb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongReinterpretedInstantColumnTupleSource.java
index 63c67cf2790..84455034e53 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongShortColumnTupleSource.java
index 6d045e47bb5..2cf2c0812eb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleLongShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleLongShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectBooleanColumnTupleSource.java
index 7b64e6356fc..8477cf4538e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleObjectByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleObjectByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectByteColumnTupleSource.java
index 0f720bcd8dc..18163a04cd2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleObjectByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleObjectByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectCharacterColumnTupleSource.java
index 6929c72cb53..c88f91fcbbe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleObjectCharTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleObjectCharTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectCharTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectColumnTupleSource.java
index 3070330a9ef..bf0d7bdf889 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectColumnTupleSource.java
@@ -76,6 +76,11 @@ public final DoubleObjectTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final DoubleObjectTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleObjectTuple, Double, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectDoubleColumnTupleSource.java
index c4f0c74232e..2ef8e1a411c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleObjectDoubleTuple tuple,
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectDouble
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectFloatColumnTupleSource.java
index 15b03c3dc38..4a56aff776d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleObjectFloatTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleObjectFloatTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectFloatT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectInstantColumnTupleSource.java
index 9aeb2a2315a..9b3d48632a5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleObjectLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleObjectLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectIntegerColumnTupleSource.java
index b4f858b9e0a..66009d2f98c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleObjectIntTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleObjectIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectIntTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectLongColumnTupleSource.java
index a3ce3a4b4f8..ea840cc2624 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleObjectLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleObjectLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectObjectColumnTupleSource.java
index 613bb7c089d..c4cab7dc67b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleObjectObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleObjectObjectTuple tuple,
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectObject
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectReinterpretedBooleanColumnTupleSource.java
index ce9c0452dd0..f3693356b81 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleObjectByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleObjectByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectReinterpretedInstantColumnTupleSource.java
index 11b009145c7..c9a4b8b8079 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleObjectLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleObjectLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectShortColumnTupleSource.java
index fc6f76a570e..a120d1fcc7d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleObjectShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleObjectShortTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleObjectShortTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleObjectShortT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanBooleanColumnTupleSource.java
index c3f0a6b2192..d868d3a85fd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanByteColumnTupleSource.java
index 4c8db9ebc54..1afd1ce04d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanCharacterColumnTupleSource.java
index 8358769468c..03f6f56e5b6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanColumnTupleSource.java
index b45c9696dfe..6cd661a07d6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final DoubleByteTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final DoubleByteTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleByteTuple, Double, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanDoubleColumnTupleSource.java
index c5a1ad0da3b..a3c6474df4c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanFloatColumnTupleSource.java
index be0aca7e6be..b39e2a0aec7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanInstantColumnTupleSource.java
index 15c65de9c90..2d9fc8436b3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final DoubleByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final DoubleByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanIntegerColumnTupleSource.java
index c94335231c9..4602b6bf2fb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanLongColumnTupleSource.java
index 64ea1ae9913..40e13ccd2f8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanObjectColumnTupleSource.java
index be1fdddd167..7db93efa682 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 1295a06026c..651d0e754ab 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index c3e91981e7b..9bcb3243bd5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final DoubleByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final DoubleByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanShortColumnTupleSource.java
index 8c898765980..031af49df29 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleByteShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleByteShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantBooleanColumnTupleSource.java
index 38292ee494e..b7bb4701880 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final DoubleLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final DoubleLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantByteColumnTupleSource.java
index e34a2af7539..1c246d6180c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantCharacterColumnTupleSource.java
index 930c081c996..2ed6f65d432 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantColumnTupleSource.java
index cb594b74ae9..15a37fdb4b1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final DoubleLongTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final DoubleLongTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleLongTuple, Double, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantDoubleColumnTupleSource.java
index c1f5e9f7073..679c5f901ad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleLongDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleLongDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantFloatColumnTupleSource.java
index a16de927030..8e89dbadb1f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantInstantColumnTupleSource.java
index fe24aea1da1..7999d130e26 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantIntegerColumnTupleSource.java
index 59ba2ee71f7..ca87375df33 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantLongColumnTupleSource.java
index d9c833e720b..2b57a8fbe71 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantObjectColumnTupleSource.java
index 1d61d51d8f4..efbb72220d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index 20c03609eaf..45578afa42a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final DoubleLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final DoubleLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index 9ed7e76abc5..4c9e0ec66fc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantShortColumnTupleSource.java
index d5a0c51ed7a..9eb298da0c6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleReinterpretedInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleLongShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleLongShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortBooleanColumnTupleSource.java
index a225032dab9..53a93e78fff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleShortByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortByteColumnTupleSource.java
index a05c4e2b2de..499c60c79df 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleShortByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortCharacterColumnTupleSource.java
index b35efa57f40..03d077b63cd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleShortCharTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleShortCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortCharTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortColumnTupleSource.java
index 2b32bcaa411..4b7caa655d7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortColumnTupleSource.java
@@ -76,6 +76,11 @@ public final DoubleShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final DoubleShortTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link DoubleShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<DoubleShortTuple, Double, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortDoubleColumnTupleSource.java
index 13863dafc49..f6a002e853f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleShortDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleShortDoubleTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortDoubleT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortFloatColumnTupleSource.java
index 7efa2eb9eab..02801a2a11f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleShortFloatTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleShortFloatTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortFloatTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortInstantColumnTupleSource.java
index 30b6e73ea67..190bdabbcdb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleShortLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortIntegerColumnTupleSource.java
index c2c3ecee9f4..23d2e3e1f29 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleShortIntTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleShortIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortIntTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortLongColumnTupleSource.java
index bde24efde5b..ad265e97b1a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleShortLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortObjectColumnTupleSource.java
index 01eb87e21f3..ca651fe2b4a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final DoubleShortObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final DoubleShortObjectTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortObjectT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortReinterpretedBooleanColumnTupleSource.java
index 2c2a63eda16..6af8c07bf68 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final DoubleShortByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final DoubleShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortReinterpretedInstantColumnTupleSource.java
index 44cf7584521..2a971da91de 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final DoubleShortLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final DoubleShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortShortColumnTupleSource.java
index 3e1cf9605ca..1a5f643398b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/DoubleShortShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final DoubleShortShortTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final DoubleShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final DoubleShortShortTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final DoubleShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final DoubleShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final DoubleShortShortTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final DoubleShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanBooleanColumnTupleSource.java
index 97210430944..5e348503e78 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanByteColumnTupleSource.java
index 7a8a5c9b258..8d4551d8662 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanCharacterColumnTupleSource.java
index a6a57e5cb07..6287159e436 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanColumnTupleSource.java
index 8e5e2047ba6..81ccdcee3f0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final FloatByteTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final FloatByteTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatByteTuple, Float, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanDoubleColumnTupleSource.java
index 9156464d225..5f4c6bb1155 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanFloatColumnTupleSource.java
index 14a783be6ee..b7783e54d9b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanInstantColumnTupleSource.java
index cc461737ae2..b8ffaa71cf4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanIntegerColumnTupleSource.java
index 72136ec43d0..df962878e9a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanLongColumnTupleSource.java
index ffd458eab03..44cdd0cb4eb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanObjectColumnTupleSource.java
index 310f459282d..0416bb10a73 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanReinterpretedBooleanColumnTupleSource.java
index b954880199f..fb8a199ff31 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanReinterpretedInstantColumnTupleSource.java
index ed6ae82ae65..998091d2a36 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final FloatByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final FloatByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanShortColumnTupleSource.java
index 8f8b624c53e..32badf91cc3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteBooleanColumnTupleSource.java
index ad3c30fc060..2a69ab31f74 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteByteColumnTupleSource.java
index 28a6125618b..04d00bb79a9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteCharacterColumnTupleSource.java
index 03cc8a50423..61ad9a33662 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteColumnTupleSource.java
index a0454966b45..5337a8623d1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteColumnTupleSource.java
@@ -76,6 +76,11 @@ public final FloatByteTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final FloatByteTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatByteTuple, Float, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteDoubleColumnTupleSource.java
index ec6f25cee1e..42de5f9afe7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteFloatColumnTupleSource.java
index d9d6ca0d124..9f696f4fb2e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatByteFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteInstantColumnTupleSource.java
index 89e218aed13..e2da6941e99 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteIntegerColumnTupleSource.java
index cbd18cb8cee..919d16e6bde 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteLongColumnTupleSource.java
index 2b945fc000d..6a144329a17 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteObjectColumnTupleSource.java
index 72542ef6694..975a36569e0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteReinterpretedBooleanColumnTupleSource.java
index 6d92b647415..753a794bd8d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteReinterpretedInstantColumnTupleSource.java
index abb8a942e0e..c9cca5cf704 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteShortColumnTupleSource.java
index d62a0cf4726..2aa38bed3d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatByteShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterBooleanColumnTupleSource.java
index f8af1c17e1b..9f981a1d9f9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatCharByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatCharByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterByteColumnTupleSource.java
index 1aae4cd9450..fa117d51a50 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatCharByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatCharByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterCharacterColumnTupleSource.java
index 1e6f22ec8bd..463dc8de73b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatCharCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatCharCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterColumnTupleSource.java
index b6fb7b5de9f..c2811b0c3c8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterColumnTupleSource.java
@@ -76,6 +76,11 @@ public final FloatCharTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final FloatCharTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatCharTuple, Float, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterDoubleColumnTupleSource.java
index b8a85c8bc30..e5001be8514 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatCharDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterFloatColumnTupleSource.java
index 623ae076b91..a9ff324eac6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatCharFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatCharFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterInstantColumnTupleSource.java
index 9973097f2c1..3d2d8ad8956 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatCharLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatCharLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterIntegerColumnTupleSource.java
index aee8e5283cb..3aae9d6cd84 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatCharIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatCharIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterLongColumnTupleSource.java
index 36e107da779..626e840abe8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatCharLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatCharLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterObjectColumnTupleSource.java
index b8a99669484..0037eaf5bfc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatCharObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatCharObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterReinterpretedBooleanColumnTupleSource.java
index c70fb6dda3d..a4ae696cc41 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatCharByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatCharByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterReinterpretedInstantColumnTupleSource.java
index f90d839b009..cf0edf7d372 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatCharLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatCharLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterShortColumnTupleSource.java
index deb49f9aa05..157d4f8b1f1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatCharacterShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatCharShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatCharShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatCharShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleBooleanColumnTupleSource.java
index 5c0d69ef095..1759af97a9d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleByteColumnTupleSource.java
index 7ae0a7671e6..a2066193321 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleCharacterColumnTupleSource.java
index 5dad0c127ea..8d65059c93f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatDoubleCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleCharTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleColumnTupleSource.java
index 64e99a56416..3d3dfbd78ee 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleColumnTupleSource.java
@@ -76,6 +76,11 @@ public final FloatDoubleTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final FloatDoubleTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatDoubleTuple, Float, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleDoubleColumnTupleSource.java
index ce845951225..a4f104669fa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatDoubleDoubleTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleDoubleT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleFloatColumnTupleSource.java
index 9a65d89e60a..8ea6af8cdc7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatDoubleFloatTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleFloatTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleInstantColumnTupleSource.java
index 6c892e7ecf2..94a771a3541 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleIntegerColumnTupleSource.java
index b657ecf63d2..a94ab386707 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatDoubleIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleIntTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleLongColumnTupleSource.java
index 7b94102031d..ea41b482158 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleObjectColumnTupleSource.java
index ac5e265a62b..2a99cd1f6ec 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatDoubleObjectTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleObjectT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleReinterpretedBooleanColumnTupleSource.java
index 4dd825195e6..e2c346f96c6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleReinterpretedInstantColumnTupleSource.java
index 8f7c9b3ebea..f0d0ac44eed 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleShortColumnTupleSource.java
index 2b3451b5dca..04e0c63eeba 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatDoubleShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatDoubleShortTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatDoubleShortTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatDoubleShortTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatBooleanColumnTupleSource.java
index 3be23dd20c1..11ff137cd14 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatFloatByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatByteColumnTupleSource.java
index fa4b5b4d83c..3040a2d3c51 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatFloatByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatCharacterColumnTupleSource.java
index ca4076b3f6e..922799e4311 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatFloatCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatFloatCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatColumnTupleSource.java
index 7bb38e88a1c..81dbd2ad490 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatColumnTupleSource.java
@@ -75,6 +75,11 @@ public final FloatFloatTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final FloatFloatTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatFloatTuple, Float, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatDoubleColumnTupleSource.java
index f7019cc6e24..69ec58ccf8d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatFloatDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatFloatColumnTupleSource.java
index 3a692bff5ba..45fcd3e39a1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatFloatColumnTupleSource.java
@@ -82,6 +82,11 @@ public final FloatFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final FloatFloatFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatInstantColumnTupleSource.java
index 4f1e7a640f4..b772a28860e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatFloatLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatIntegerColumnTupleSource.java
index f7cb803f27d..93fa380bd1c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatFloatIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatFloatIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatLongColumnTupleSource.java
index 25e261629e8..f256385e698 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatFloatLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatObjectColumnTupleSource.java
index 6f083dbc923..77d4c2a9da3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatFloatObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatFloatObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatReinterpretedBooleanColumnTupleSource.java
index 9c13c822a39..f8a2f86539b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatFloatByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatReinterpretedInstantColumnTupleSource.java
index 07bf159270a..c54b7b3988d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatFloatLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatShortColumnTupleSource.java
index dbcefefacb1..a641994d77f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatFloatShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatFloatShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatFloatShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatFloatShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantBooleanColumnTupleSource.java
index 84779e3fc20..4a6580e3580 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantByteColumnTupleSource.java
index 4f9b58ba1a1..00ea928be8f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantCharacterColumnTupleSource.java
index f933a179ab6..649dffabccc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantColumnTupleSource.java
index 97a6725a5c5..609328eb16f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final FloatLongTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final FloatLongTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatLongTuple, Float, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantDoubleColumnTupleSource.java
index 8bd34dc7b16..298f0eefa2a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantFloatColumnTupleSource.java
index ab300fec62f..95facfa6514 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatLongFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantInstantColumnTupleSource.java
index 8c43dd9f7eb..0153394fd37 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantIntegerColumnTupleSource.java
index ef455f7a115..31e5ae6a12e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantLongColumnTupleSource.java
index 5377e46572a..6d323cfd56a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantObjectColumnTupleSource.java
index bce9765ccdc..7c613041bba 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatLongObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantReinterpretedBooleanColumnTupleSource.java
index 38859bccb93..f253d839995 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final FloatLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final FloatLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantReinterpretedInstantColumnTupleSource.java
index 570ee1cefd9..d614048cf42 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantShortColumnTupleSource.java
index 71e43ba2712..873fc71fa02 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerBooleanColumnTupleSource.java
index 566ed944334..c60b6120bfa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatIntByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerByteColumnTupleSource.java
index 8471e2c7f19..14a81209b01 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatIntByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerCharacterColumnTupleSource.java
index f22535147ab..c704fca18e5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatIntCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatIntCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerColumnTupleSource.java
index 541c2d793b4..5f3c0fce4ab 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerColumnTupleSource.java
@@ -76,6 +76,11 @@ public final FloatIntTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final FloatIntTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatIntTuple, Float, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerDoubleColumnTupleSource.java
index 6997991facb..cf36f4238d6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatIntDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerFloatColumnTupleSource.java
index bf28e501385..0ebed1ee9c4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatIntFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatIntFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerInstantColumnTupleSource.java
index 1d1836f5c7d..ac0234ffbb6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatIntLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerIntegerColumnTupleSource.java
index ace52c03d1a..6a5e2941dfe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatIntIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatIntIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerLongColumnTupleSource.java
index 73cf549c451..e9c5d8dd9e5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatIntLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerObjectColumnTupleSource.java
index 1c283164d6f..b08257fa226 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatIntObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatIntObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerReinterpretedBooleanColumnTupleSource.java
index 87edec54017..91ec2924162 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatIntByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerReinterpretedInstantColumnTupleSource.java
index cb15edcba30..564572f9dce 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatIntLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerShortColumnTupleSource.java
index d81377826a7..26f83999f95 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatIntegerShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatIntShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatIntShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatIntShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongBooleanColumnTupleSource.java
index 5b2aa78c097..437360113c6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongByteColumnTupleSource.java
index 628b13a871a..9f2ee4ac5be 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongCharacterColumnTupleSource.java
index d6cad53c212..e4ce785c078 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatLongCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatLongCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongColumnTupleSource.java
index 207b915f3d0..103f19d1c5f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongColumnTupleSource.java
@@ -76,6 +76,11 @@ public final FloatLongTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final FloatLongTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatLongTuple, Float, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongDoubleColumnTupleSource.java
index 7bd2e3ecfd5..3f6bf85b45e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongFloatColumnTupleSource.java
index c54c8685aa3..99baf934991 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatLongFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongInstantColumnTupleSource.java
index 893bb56a8ec..04bfabf6ae5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongIntegerColumnTupleSource.java
index 09282ff070b..8e998b64418 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatLongIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongLongColumnTupleSource.java
index 1d13aa2e4f3..780ebaae1d7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongObjectColumnTupleSource.java
index 920fd3b70b5..1b081bb079d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatLongObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongReinterpretedBooleanColumnTupleSource.java
index ec2edc029cc..1f97b455f3b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongReinterpretedInstantColumnTupleSource.java
index 1791d6e03ce..ead0cddb87c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongShortColumnTupleSource.java
index b96f6321139..8f8011052fc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatLongShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatLongShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectBooleanColumnTupleSource.java
index 93860df97e0..4c501623588 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatObjectByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectByteColumnTupleSource.java
index bc037fe8ea5..82375d0a722 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatObjectByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectCharacterColumnTupleSource.java
index 034cc0148fb..a74214afe22 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatObjectCharTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatObjectCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectCharTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectColumnTupleSource.java
index 361e99dcf8c..a16c685576f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectColumnTupleSource.java
@@ -76,6 +76,11 @@ public final FloatObjectTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final FloatObjectTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatObjectTuple, Float, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectDoubleColumnTupleSource.java
index c998e9435b5..e47ec6f6f11 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatObjectDoubleTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectDoubleT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectFloatColumnTupleSource.java
index 33e288bbfb7..c46bb6b6ba9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatObjectFloatTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatObjectFloatTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectFloatTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectInstantColumnTupleSource.java
index c1a63dc3719..08cf6825bb6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatObjectLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectIntegerColumnTupleSource.java
index 442eee04683..1e2778bad42 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatObjectIntTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatObjectIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectIntTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectLongColumnTupleSource.java
index 92802868f4b..a4f46ff3d95 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatObjectLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectObjectColumnTupleSource.java
index 68849d0bbfb..54db43c9303 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatObjectObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatObjectObjectTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectObjectT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectReinterpretedBooleanColumnTupleSource.java
index 31d7b1a3fc5..e542bfdd662 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatObjectByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectReinterpretedInstantColumnTupleSource.java
index 30c145c41a8..afc5b449ee7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatObjectLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectShortColumnTupleSource.java
index 174451e240d..cb531fd50af 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatObjectShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatObjectShortTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatObjectShortTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatObjectShortTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanBooleanColumnTupleSource.java
index 740ea31bbac..61fa03f9db4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanByteColumnTupleSource.java
index d55b98e6d83..e3e2ddafe2a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanCharacterColumnTupleSource.java
index d63d334d8f8..555a47015ab 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanColumnTupleSource.java
index 8b5305bcc30..020f717e832 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final FloatByteTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final FloatByteTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatByteTuple, Float, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanDoubleColumnTupleSource.java
index 448a2c4e950..d98c364c26d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanFloatColumnTupleSource.java
index bdb0313ba05..033719260a8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanInstantColumnTupleSource.java
index eb840632c8d..626a09180c6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final FloatByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final FloatByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanIntegerColumnTupleSource.java
index 61698d2e276..f2b57d0e16b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanLongColumnTupleSource.java
index c7af4cc8f38..9d424a3023a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanObjectColumnTupleSource.java
index 3c9d7b6827b..6b7719c58c3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 27d78498a3e..e1b994f4542 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index b63202a52a9..28bb5a50856 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final FloatByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final FloatByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanShortColumnTupleSource.java
index ed1a7e3fee0..a041813c13d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatByteShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatByteShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantBooleanColumnTupleSource.java
index 1b3b6fca73c..d689a988d5e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final FloatLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final FloatLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantByteColumnTupleSource.java
index b051d27f828..32e8e240a37 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantCharacterColumnTupleSource.java
index dcb2e045edd..ec752ea345a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantColumnTupleSource.java
index 7405d1fe874..f2f410bd927 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final FloatLongTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final FloatLongTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatLongTuple, Float, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantDoubleColumnTupleSource.java
index 800bc286a86..eebe86a5aa6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantFloatColumnTupleSource.java
index 17800d27cf2..58ec1f10540 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatLongFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantInstantColumnTupleSource.java
index 2b1d7246943..519ec92bfd2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantIntegerColumnTupleSource.java
index fb0e6a96742..e03f9d1ca9a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantLongColumnTupleSource.java
index 4778c22d94e..d4a39df2cff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantObjectColumnTupleSource.java
index fd4a71fe85c..66c36ba58e4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index a18ef229daa..d8b1d35b787 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final FloatLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final FloatLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index c2307250915..29642ec80bb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantShortColumnTupleSource.java
index 05b60ca5432..6b8ff847e70 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatReinterpretedInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatLongShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatLongShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortBooleanColumnTupleSource.java
index 82acdf49de5..8bc68310c35 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatShortByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortByteColumnTupleSource.java
index b32d56a68b8..461255fede4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatShortByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortCharacterColumnTupleSource.java
index 855aa1e7da6..813242960b5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatShortCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatShortCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortColumnTupleSource.java
index 955cd4e19b4..a0a1fc6964a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortColumnTupleSource.java
@@ -76,6 +76,11 @@ public final FloatShortTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final FloatShortTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link FloatShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<FloatShortTuple, Float, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortDoubleColumnTupleSource.java
index 07471ff1fa3..d0f979f830d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatShortDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatShortDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortFloatColumnTupleSource.java
index a8a862a7290..6e14e9fd115 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatShortFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatShortFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortInstantColumnTupleSource.java
index cb5a86c203b..b9e866a41fe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatShortLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortIntegerColumnTupleSource.java
index cef406d7fa2..da451e511b6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatShortIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatShortIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortLongColumnTupleSource.java
index ceb6bec4c00..20bb61d93bf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatShortLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortObjectColumnTupleSource.java
index 1ca149db8d1..bb2ede98907 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final FloatShortObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final FloatShortObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortReinterpretedBooleanColumnTupleSource.java
index b25da29b15e..49e813ee94a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final FloatShortByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final FloatShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortReinterpretedInstantColumnTupleSource.java
index afb53d5fbe8..c8207b30574 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final FloatShortLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final FloatShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortShortColumnTupleSource.java
index 36aac65b167..af26acc5cc3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/FloatShortShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final FloatShortShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final FloatShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final FloatShortShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final FloatShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final FloatShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final FloatShortShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final FloatShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanBooleanColumnTupleSource.java
index 25356d22eab..1573327bbed 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanByteColumnTupleSource.java
index 4e9a1f1687b..41c1bd14e06 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanCharacterColumnTupleSource.java
index 3cbc15747d4..17c656ee0c6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanColumnTupleSource.java
index ce4388ff7c7..9c3fd80bbbd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final LongByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final LongByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongByteTuple, Instant, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanDoubleColumnTupleSource.java
index 082403c74b5..e34fb1f4e6f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanFloatColumnTupleSource.java
index f42196016b4..4d0ee895ac0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanInstantColumnTupleSource.java
index ba82d396c01..2f69826344f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanInstantColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanIntegerColumnTupleSource.java
index e74c84ee60b..69c97168f3b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanLongColumnTupleSource.java
index 5509db2c936..179b2a49af7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanObjectColumnTupleSource.java
index 595b0afa87e..1fa266c8217 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanReinterpretedBooleanColumnTupleSource.java
index bb148a95fb9..51faa2d2691 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanReinterpretedInstantColumnTupleSource.java
index 8fad061f892..b826232a178 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanShortColumnTupleSource.java
index 265f06468ed..ca403fba5be 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantBooleanShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteBooleanColumnTupleSource.java
index da471bd1150..0b6e5bcbb44 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteByteColumnTupleSource.java
index 7b9a2987738..5d8b42ff102 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteCharacterColumnTupleSource.java
index f51be3068c4..3df9d0138ea 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteColumnTupleSource.java
index b96b1468966..ce10f204e32 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongByteTuple, Instant, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteDoubleColumnTupleSource.java
index 2343ce5586d..64ff83e9020 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteFloatColumnTupleSource.java
index 161e2e36b42..8a50b8cf3c2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteInstantColumnTupleSource.java
index ba73325395c..82f8ac4ca9a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteIntegerColumnTupleSource.java
index 8231c82f144..8fb1bb9a02c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteLongColumnTupleSource.java
index d3c6a453b85..ea6a011cbaa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteObjectColumnTupleSource.java
index 65879c82637..fba7de0bbfd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteReinterpretedBooleanColumnTupleSource.java
index 2eb5bef9381..02510f2c3f2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteReinterpretedInstantColumnTupleSource.java
index cfd6fa22784..fdcf00b40e6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteShortColumnTupleSource.java
index dbc78a98030..a326ec409f1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantByteShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterBooleanColumnTupleSource.java
index c168a6e7efa..5a92e32694c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterByteColumnTupleSource.java
index 4f670b0a5db..1e9d19f2ef4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterCharacterColumnTupleSource.java
index 48d931d1661..29baf66d1d8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongCharCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongCharCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterColumnTupleSource.java
index fda6ea791ce..525ce1e667d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongCharTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongCharTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongCharTuple, Instant, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterDoubleColumnTupleSource.java
index d8a9173f83c..9649ce28853 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterFloatColumnTupleSource.java
index 23e6d463f8f..33a28870621 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterInstantColumnTupleSource.java
index c262c3ad0c4..603969373db 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterIntegerColumnTupleSource.java
index e3007022944..a9c1398d184 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterLongColumnTupleSource.java
index bca86bda49d..225d4f50233 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterObjectColumnTupleSource.java
index b2ba35b1e7f..4f40624f46a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongCharObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongCharObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterReinterpretedBooleanColumnTupleSource.java
index faa44a72ccb..bedcc563089 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterReinterpretedInstantColumnTupleSource.java
index cf5c6620426..bdad6abd842 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterShortColumnTupleSource.java
index c6ef2369f2d..cf11d073e99 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantCharacterShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleBooleanColumnTupleSource.java
index 2ea00debfe9..50dfaff765b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleByteColumnTupleSource.java
index 992c4bbaeff..fd8af41a423 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleCharacterColumnTupleSource.java
index 679a1536da3..5d25e3fc429 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleColumnTupleSource.java
index c00ee5b89a7..b3e7f4d755e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongDoubleTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongDoubleTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongDoubleTuple, Instant, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleDoubleColumnTupleSource.java
index 6f88dd97e7f..ee2719e20ec 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongDoubleDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleFloatColumnTupleSource.java
index 190a87b7785..8c79411a95c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleInstantColumnTupleSource.java
index fae31b538d1..720a9206f1b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleIntegerColumnTupleSource.java
index db828aecc35..774a8a66a66 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleLongColumnTupleSource.java
index 4d9cc9306d9..d5162b3575f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleObjectColumnTupleSource.java
index 23de5d1b2bc..8b1a8adb33c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongDoubleObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleReinterpretedBooleanColumnTupleSource.java
index b6ea3b867f6..a0a704615ef 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleReinterpretedInstantColumnTupleSource.java
index cef0e9d6a2b..f5ce62b3f56 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleShortColumnTupleSource.java
index 730824725f9..b614179f333 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantDoubleShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatBooleanColumnTupleSource.java
index 43986ef4572..939b46d8958 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatByteColumnTupleSource.java
index 12ef15ac9c3..09d920fc17a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatCharacterColumnTupleSource.java
index 58de5f3e6f5..b8fda2e2da0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatColumnTupleSource.java
index 332e638b0bb..c96848cacd6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongFloatTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongFloatTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongFloatTuple, Instant, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatDoubleColumnTupleSource.java
index 6a04c3f17da..a81ce273223 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatFloatColumnTupleSource.java
index 6c36f399ba4..0bad2168a8f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongFloatFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatInstantColumnTupleSource.java
index 78cba805f03..74b97e9a0e2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatIntegerColumnTupleSource.java
index f0c6ca60ebf..9f58bce06d8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatLongColumnTupleSource.java
index 493114fec80..a6e2de4a7ac 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatObjectColumnTupleSource.java
index 9b42a18db8d..8eea00c5400 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongFloatObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongFloatObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatReinterpretedBooleanColumnTupleSource.java
index 49904c3a22e..870810f6543 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatReinterpretedInstantColumnTupleSource.java
index 9cc96d95a73..abedcb62447 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatShortColumnTupleSource.java
index c6785d623d3..c925c1a2acf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantFloatShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantBooleanColumnTupleSource.java
index f963039a502..a2097fb9f83 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantByteColumnTupleSource.java
index c0d5619eae8..1c6356ff0e8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantCharacterColumnTupleSource.java
index d6b921f0ed4..07303c2c808 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantColumnTupleSource.java
index 08682e05bce..41e719175f3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantColumnTupleSource.java
@@ -76,6 +76,11 @@ public final LongLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final LongLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongLongTuple, Instant, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantDoubleColumnTupleSource.java
index d5ee3cef2c5..20737adbb29 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantFloatColumnTupleSource.java
index cf7462b4ef0..3505b5324c3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantInstantColumnTupleSource.java
index 199e8ef24cc..c85c5bd7b6c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantInstantColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantIntegerColumnTupleSource.java
index defa8234334..4082f4f8202 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantLongColumnTupleSource.java
index 91fc2b0b30a..8112f30cb0f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantObjectColumnTupleSource.java
index 5777b53d80b..d8a2b3363f8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantReinterpretedBooleanColumnTupleSource.java
index 6b8698b60eb..c43d5a4b822 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantReinterpretedInstantColumnTupleSource.java
index 9a3dae0d43e..b3778f7d9fb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantShortColumnTupleSource.java
index 0c5b1cc0cd9..9774fb769f8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantInstantShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerBooleanColumnTupleSource.java
index 1267c576c41..badf4b5c64e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerByteColumnTupleSource.java
index 09be8a13ee9..4f883072580 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerCharacterColumnTupleSource.java
index a274b00e7f6..1c8a61aaba7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerColumnTupleSource.java
index 3a4cf4c05a5..c2ff5349028 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongIntTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongIntTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongIntTuple, Instant, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerDoubleColumnTupleSource.java
index 6e066fb5af4..808cad3167a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerFloatColumnTupleSource.java
index 1d99df7d895..8c01ff2aefc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerInstantColumnTupleSource.java
index 95bb9ee67e8..f0a7ce96aaa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerIntegerColumnTupleSource.java
index 3d779ceaefa..21f90b53d1a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongIntIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongIntIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerLongColumnTupleSource.java
index 9ceb7ff12b9..9e1c94c1e47 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerObjectColumnTupleSource.java
index 351807659d7..d22845ee738 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongIntObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongIntObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerReinterpretedBooleanColumnTupleSource.java
index 291365c2fee..662d137b557 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerReinterpretedInstantColumnTupleSource.java
index 93aab21c27d..0b1befd164a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerShortColumnTupleSource.java
index 21696ed841a..f4ebf844e24 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantIntegerShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongBooleanColumnTupleSource.java
index 1e279bc457d..ceb9e518d72 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongByteColumnTupleSource.java
index 836a297894f..90e47cb3881 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongCharacterColumnTupleSource.java
index 31e37707bba..7aa6bc43dcf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongColumnTupleSource.java
index fd7d2648513..7a3e2a7922c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongLongTuple, Instant, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongDoubleColumnTupleSource.java
index 37efe4267ee..6e2951b1794 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongFloatColumnTupleSource.java
index d3fc3f634f5..df16540cd17 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongInstantColumnTupleSource.java
index 33876c83e6c..9fb2b0000eb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongIntegerColumnTupleSource.java
index d1f4ee7527d..091197eb09f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongLongColumnTupleSource.java
index 2bb0023a3a2..ec90bdd1faf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongObjectColumnTupleSource.java
index e944d377a59..977d6c12a7f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongReinterpretedBooleanColumnTupleSource.java
index 71be98ca8d4..8d67de07fdc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongReinterpretedInstantColumnTupleSource.java
index 1d07f51f30c..7f9604aac3a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongShortColumnTupleSource.java
index 38c474c3842..696ad157dc2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantLongShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectBooleanColumnTupleSource.java
index a6336440176..76b04d49751 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectByteColumnTupleSource.java
index b0836fbd4e0..e8398724680 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectCharacterColumnTupleSource.java
index ed01fe96cd1..7e38fe1c227 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectColumnTupleSource.java
index 3b0c496db8d..3670da4c370 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectColumnTupleSource.java
@@ -76,6 +76,11 @@ public final LongObjectTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final LongObjectTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongObjectTuple, Instant, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectDoubleColumnTupleSource.java
index 104892cc386..3d82a27dcf6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectFloatColumnTupleSource.java
index 71c97740dd6..ba2037f5ba1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectInstantColumnTupleSource.java
index fc0c1f35c7d..acd6a266208 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectInstantColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectIntegerColumnTupleSource.java
index 6223c2fddf4..49c991994bc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectLongColumnTupleSource.java
index 2b7f171c2e9..2d33650957b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectObjectColumnTupleSource.java
index 98b07951f66..7e3d012f2fb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongObjectObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongObjectObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectReinterpretedBooleanColumnTupleSource.java
index da0d595caa1..8042e36da6f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectReinterpretedInstantColumnTupleSource.java
index 1dccb9fbfca..48fac9d6458 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectShortColumnTupleSource.java
index b6dbd54fc37..fbd0e6c96e8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantObjectShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanBooleanColumnTupleSource.java
index 239ef5811ca..973b55dd400 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanByteColumnTupleSource.java
index 2949b62c81a..81d5b4b5817 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanCharacterColumnTupleSource.java
index 30010c38197..9670ac8708a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanCharacterColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanColumnTupleSource.java
index f121807343a..32e4c9d4c15 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanColumnTupleSource.java
@@ -79,6 +79,11 @@ public final LongByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -104,6 +109,18 @@ public final Object exportElement(@NotNull final LongByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -125,6 +142,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongByteTuple, Instant, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanDoubleColumnTupleSource.java
index 5dfc036fd93..78c6ba9d5dc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanDoubleColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanFloatColumnTupleSource.java
index 184b5c9b3aa..344ed6ff75a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanFloatColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanInstantColumnTupleSource.java
index ef752bfaafa..03cb214734d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanIntegerColumnTupleSource.java
index 3d5117e18a8..12910c2e2ff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanIntegerColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanLongColumnTupleSource.java
index b0114aebeb9..51624fa0c85 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanLongColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanObjectColumnTupleSource.java
index 27343f1d636..224ea3525c9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 98a8a387a38..c3c6e033d9b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 93dbfc25954..66ab64878a2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanShortColumnTupleSource.java
index b0d1f3af3a5..5e50d074321 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedBooleanShortColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantBooleanColumnTupleSource.java
index dc7aea419fe..5d7ceb34fdb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantByteColumnTupleSource.java
index 8cbd5ab9096..ec949aa729c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantCharacterColumnTupleSource.java
index e520a327dc8..283a3945118 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantColumnTupleSource.java
index cc7c4fa13c9..ebda86753cd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongLongTuple, Instant, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantDoubleColumnTupleSource.java
index 80bdafda8eb..e88f204332e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantFloatColumnTupleSource.java
index b31ab491126..fc86c61a2f4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantInstantColumnTupleSource.java
index 5db0ee1e8b4..1f9fe3a4c30 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantIntegerColumnTupleSource.java
index fb09c7795c1..a17b595c962 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantLongColumnTupleSource.java
index ac33ed7507f..e174d7f044d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantObjectColumnTupleSource.java
index 923801a9b59..9f87f68889f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index c8fbac83479..efe9c2a44e8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index 20ec8295271..bdcfe2b6c2a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantShortColumnTupleSource.java
index 0ece28182c4..edd5305b3fa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantReinterpretedInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortBooleanColumnTupleSource.java
index b2fe05fcc76..30fa280d837 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortByteColumnTupleSource.java
index 8792edb1cbc..265c76c2fee 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortCharacterColumnTupleSource.java
index 870bf9389c1..1af7f470096 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortColumnTupleSource.java
index 518370e9670..fa841fad8da 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongShortTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongShortTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link InstantShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongShortTuple, Instant, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortDoubleColumnTupleSource.java
index 1fadfdbc28b..cbacf569940 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortFloatColumnTupleSource.java
index fdd3f5404a2..82b28dcd374 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortInstantColumnTupleSource.java
index d28eab425d9..ac3e64ea292 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortIntegerColumnTupleSource.java
index 64a9a1004cb..39f1738b278 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortLongColumnTupleSource.java
index 378ca6f43ab..d2def9adee9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortObjectColumnTupleSource.java
index 5851017775f..aabd44af1b7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongShortObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongShortObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortReinterpretedBooleanColumnTupleSource.java
index b21aab2d777..72f69ee12ed 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortReinterpretedInstantColumnTupleSource.java
index d9b8b8e30b8..716e7890789 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortShortColumnTupleSource.java
index a949d755144..89369224ac8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/InstantShortShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongShortShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongShortShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanBooleanColumnTupleSource.java
index 21dcaf01145..fec113714d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanByteColumnTupleSource.java
index 199d5a0b4c3..9b92821284e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanCharacterColumnTupleSource.java
index 1dfb00cf6a8..82c7a6651c7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanColumnTupleSource.java
index 247dedd48b0..40f679224c0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final IntByteTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final IntByteTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntByteTuple, Integer, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanDoubleColumnTupleSource.java
index e248fc0f418..87706d9a928 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanFloatColumnTupleSource.java
index f79519d6027..f59cea522b8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanInstantColumnTupleSource.java
index 1025b1a296a..80b80990d3e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntByteLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanIntegerColumnTupleSource.java
index 137db718bc7..b553993f9f5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanLongColumnTupleSource.java
index 48da4614b3b..cebca141bb3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanObjectColumnTupleSource.java
index f4c589dffd6..df4818d6857 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanReinterpretedBooleanColumnTupleSource.java
index 4e38fa6dd6c..4bba54b1ac7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanReinterpretedInstantColumnTupleSource.java
index 0a3d9bf153b..83fa381946b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final IntByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final IntByteLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanShortColumnTupleSource.java
index bcc616c9c43..819e62379b0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteBooleanColumnTupleSource.java
index 2c195c2c335..cffbe047ccb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteByteColumnTupleSource.java
index 2fa8f2ca6ea..6349e947c9a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntByteByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteCharacterColumnTupleSource.java
index 84fefc3ac2f..934c218d6e6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteColumnTupleSource.java
index 940bd9b5dbb..f26734551e5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteColumnTupleSource.java
@@ -76,6 +76,11 @@ public final IntByteTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final IntByteTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntByteTuple, Integer, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteDoubleColumnTupleSource.java
index 8c4f3a1e1b2..e5ce61fe3f7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteFloatColumnTupleSource.java
index d3a700a640e..0c2771abf80 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteInstantColumnTupleSource.java
index 57eff4eec7a..7b5121abae4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntByteLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteIntegerColumnTupleSource.java
index 39aa4e7bfda..a59c4ce1ab6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntByteIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntByteIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteLongColumnTupleSource.java
index 0189a4a5927..7741ffc36d4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteObjectColumnTupleSource.java
index 3f244be1357..2661cd96aae 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteReinterpretedBooleanColumnTupleSource.java
index 527bbd9e7fa..008268983a0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteReinterpretedInstantColumnTupleSource.java
index 462687d40a9..fba4edcbab6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntByteLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteShortColumnTupleSource.java
index 8d783da391e..36d3cd6d695 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerByteShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterBooleanColumnTupleSource.java
index 392dce5cc11..debe5ea4d61 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntCharByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterByteColumnTupleSource.java
index 8d4e27dcb00..93cb0dc2e24 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntCharByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterCharacterColumnTupleSource.java
index c998e6ae740..c46999ece78 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntCharCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntCharCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterColumnTupleSource.java
index 735688b7539..24a47c25d4c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterColumnTupleSource.java
@@ -76,6 +76,11 @@ public final IntCharTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final IntCharTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntCharTuple, Integer, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterDoubleColumnTupleSource.java
index 6e424e387af..c1f5e5d1123 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntCharDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterFloatColumnTupleSource.java
index aa0f0f7d0f2..3cd30a8432c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntCharFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntCharFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterInstantColumnTupleSource.java
index 0aaf452c70f..cf48be2b8e3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntCharLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterIntegerColumnTupleSource.java
index 6f03ecbaea6..6a4b8f934ad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntCharIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntCharIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterLongColumnTupleSource.java
index 8ee2bb2ea77..2dc4d198c43 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntCharLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterObjectColumnTupleSource.java
index 68143ddc712..f10e2c5af20 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntCharObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntCharObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterReinterpretedBooleanColumnTupleSource.java
index a1b6ef9078f..f4251aff8be 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntCharByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterReinterpretedInstantColumnTupleSource.java
index 7211bb8eef2..3c9ec1715ff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntCharLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterShortColumnTupleSource.java
index 71c89bd666f..c8df49ba4f9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerCharacterShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntCharShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntCharShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntCharShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleBooleanColumnTupleSource.java
index 7e09d609859..653319bb4e1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntDoubleByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleByteColumnTupleSource.java
index a21e949e7e9..9056238b682 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntDoubleByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleCharacterColumnTupleSource.java
index 44f3e85f177..d1d6950369c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntDoubleCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleColumnTupleSource.java
index 22f54212af8..0659f92063c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleColumnTupleSource.java
@@ -76,6 +76,11 @@ public final IntDoubleTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final IntDoubleTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntDoubleTuple, Integer, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleDoubleColumnTupleSource.java
index 642bee2312a..c89f3d1e6df 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntDoubleDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleFloatColumnTupleSource.java
index b99b21bd5f3..7bc850f8e44 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntDoubleFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleInstantColumnTupleSource.java
index 4ba4999cd77..224dbc6eac9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntDoubleLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleIntegerColumnTupleSource.java
index 1f1fa157a9c..dda10f2316e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntDoubleIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntDoubleIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleLongColumnTupleSource.java
index 75944f2a38d..83c65cb9df2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntDoubleLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleObjectColumnTupleSource.java
index 9d7db01e9bc..d418b3f73e3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntDoubleObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleReinterpretedBooleanColumnTupleSource.java
index edb1ca78b6e..6cb7748b895 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntDoubleByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleReinterpretedInstantColumnTupleSource.java
index 0ec63160376..e11f9952eb5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntDoubleLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleShortColumnTupleSource.java
index f3f07b992ba..06fcc66596e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerDoubleShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntDoubleShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntDoubleShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntDoubleShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatBooleanColumnTupleSource.java
index 7b8d31f1b15..4383a007da9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntFloatByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntFloatByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatByteColumnTupleSource.java
index 17bc35b3eca..90452471f8f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntFloatByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntFloatByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatCharacterColumnTupleSource.java
index 5f0a27ed48d..ec6bd9be05c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntFloatCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntFloatCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatColumnTupleSource.java
index f2b0077c323..a39dd39deb0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatColumnTupleSource.java
@@ -76,6 +76,11 @@ public final IntFloatTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final IntFloatTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntFloatTuple, Integer, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatDoubleColumnTupleSource.java
index 83437b77eb4..7c098aaf055 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntFloatDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatFloatColumnTupleSource.java
index dde03bf74c2..0ad7cd33bd2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntFloatFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatInstantColumnTupleSource.java
index 14ba85c2a9f..2891a23bba8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntFloatLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntFloatLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatIntegerColumnTupleSource.java
index 53063f86339..4726414cb1e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntFloatIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntFloatIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatLongColumnTupleSource.java
index 3808da0b53d..b93c5b6d9fe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntFloatLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntFloatLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatObjectColumnTupleSource.java
index daa7507e88e..0dc560ff795 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntFloatObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntFloatObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatReinterpretedBooleanColumnTupleSource.java
index 946c8dc8a37..033275f0533 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntFloatByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntFloatByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatReinterpretedInstantColumnTupleSource.java
index 4a5c7aad476..97e0457a024 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntFloatLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntFloatLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatShortColumnTupleSource.java
index 49bfa8b1a99..c165f953eee 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerFloatShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntFloatShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntFloatShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntFloatShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantBooleanColumnTupleSource.java
index 4bd2f378e2f..f14e6599e50 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantByteColumnTupleSource.java
index cc2029bcf3f..0721217742f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantCharacterColumnTupleSource.java
index ac67cd79075..7ee0d61439d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantColumnTupleSource.java
index 1e4039a71bb..e55f770c954 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final IntLongTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final IntLongTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntLongTuple, Integer, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantDoubleColumnTupleSource.java
index 706b2d8f88e..c8c2e8fb0a9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantFloatColumnTupleSource.java
index 28093483e33..5e1eb749dbd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantInstantColumnTupleSource.java
index eac2e7d63ad..2d4b3ab5b65 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntLongLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantIntegerColumnTupleSource.java
index d85c426ffd4..85a8425efd0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntLongIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntLongIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantLongColumnTupleSource.java
index 79a9599660d..17ad6a99f60 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantObjectColumnTupleSource.java
index 3d96f6f5df3..ba539b4ebf6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntLongObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntLongObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantReinterpretedBooleanColumnTupleSource.java
index 0e7c2f1db89..2d6a2cbbdfd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final IntLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final IntLongByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantReinterpretedInstantColumnTupleSource.java
index 29531419fd9..cc9ea4e5164 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantShortColumnTupleSource.java
index f2cc1f82aa4..95c05c6e47d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerBooleanColumnTupleSource.java
index 75d3cfea14d..5688ed19bed 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntIntByteTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntIntByteTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntByteTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerByteColumnTupleSource.java
index a0ee5c9bc07..a554bbd36c0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntIntByteTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntIntByteTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntByteTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerCharacterColumnTupleSource.java
index 65ddc4f555d..6bcd3b846b1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntIntCharTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntIntCharTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntCharTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerColumnTupleSource.java
index e76b41c54b1..eb736d05334 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerColumnTupleSource.java
@@ -75,6 +75,11 @@ public final IntIntTuple createTupleFromReinterpretedValues(@NotNull final Objec
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final IntIntTuple tuple, int elementI
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntIntTuple, Integer, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerDoubleColumnTupleSource.java
index 0e77b0a60f1..ed2be63c338 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntIntDoubleTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntIntDoubleTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerFloatColumnTupleSource.java
index 020912bf4a1..96a30616da9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntIntFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntIntFloatTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntFloatTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerInstantColumnTupleSource.java
index 5f5a0a8c840..26448516f13 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntIntLongTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntIntLongTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntLongTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerIntegerColumnTupleSource.java
index 9bc776cd09f..aa024c894eb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerIntegerColumnTupleSource.java
@@ -82,6 +82,11 @@ public final IntIntIntTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final IntIntIntTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntIntTuple tup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerLongColumnTupleSource.java
index 41392913eae..b5bec2899e1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntIntLongTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntIntLongTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntLongTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerObjectColumnTupleSource.java
index c3cb900e0bc..459af947413 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntIntObjectTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntIntObjectTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerReinterpretedBooleanColumnTupleSource.java
index c18da8b5c1f..4f8513418de 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntIntByteTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntIntByteTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntByteTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerReinterpretedInstantColumnTupleSource.java
index 59154c981ca..e50f20b90d7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntIntLongTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntIntLongTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntLongTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerShortColumnTupleSource.java
index 923c1395cfc..49b1e40a1ce 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerIntegerShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntIntShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntIntShortTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntIntShortTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongBooleanColumnTupleSource.java
index 2bb23261c71..782d1f2b9cf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntLongByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongByteColumnTupleSource.java
index c50fa2fca4b..190de2d4cd0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntLongByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongCharacterColumnTupleSource.java
index f56e3085725..b24e256df07 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntLongCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongColumnTupleSource.java
index c3a357067a1..e4f516de04a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongColumnTupleSource.java
@@ -76,6 +76,11 @@ public final IntLongTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final IntLongTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntLongTuple, Integer, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongDoubleColumnTupleSource.java
index 3df2adedb8f..f43d0272d44 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntLongDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongFloatColumnTupleSource.java
index 768370e3b81..fbc4a2d7747 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntLongFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntLongFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongInstantColumnTupleSource.java
index 81a336d7d06..22e0a91236e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongIntegerColumnTupleSource.java
index 6c484e8bd59..16d049cd5b3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntLongIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntLongIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongLongColumnTupleSource.java
index fcad157b7b1..7456d32f138 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntLongLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongObjectColumnTupleSource.java
index 257d6eae34b..2d8d7b6a2b9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntLongObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntLongObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongReinterpretedBooleanColumnTupleSource.java
index c50c091691c..fdebc79858f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntLongByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongReinterpretedInstantColumnTupleSource.java
index 9571a1da879..8df9f7c139b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntLongLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongShortColumnTupleSource.java
index 4888f87ef99..803869d0580 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerLongShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntLongShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntLongShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectBooleanColumnTupleSource.java
index 510c04d0983..f67f9c60f0a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntObjectByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntObjectByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectByteColumnTupleSource.java
index f7f8ace4387..6e7497b31e6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntObjectByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntObjectByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectCharacterColumnTupleSource.java
index 7386cb1ce81..9dce3b440c0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntObjectCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntObjectCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectColumnTupleSource.java
index 23e4adc7b1a..e962bc30c9f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectColumnTupleSource.java
@@ -76,6 +76,11 @@ public final IntObjectTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final IntObjectTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntObjectTuple, Integer, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectDoubleColumnTupleSource.java
index 13ef1b3d6c1..aa7c1a9c7d3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntObjectDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectFloatColumnTupleSource.java
index cd13fa6d7d6..63dd9eb4402 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntObjectFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntObjectFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectInstantColumnTupleSource.java
index 64418e41a7c..ec298ef6f2e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntObjectLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntObjectLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectIntegerColumnTupleSource.java
index 5346804dcf6..0a542ae2190 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntObjectIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntObjectIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectLongColumnTupleSource.java
index e14089b303a..9510c53876f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntObjectLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntObjectLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectObjectColumnTupleSource.java
index b1818e827f1..60c3cd4e896 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntObjectObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntObjectObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectReinterpretedBooleanColumnTupleSource.java
index 3c24fb28eac..969c2a65fad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntObjectByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntObjectByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectReinterpretedInstantColumnTupleSource.java
index 6b02f2ed3b1..95bd72a68a1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntObjectLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntObjectLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectShortColumnTupleSource.java
index 0d3ee60eb7e..1e710636d9d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerObjectShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntObjectShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntObjectShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntObjectShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanBooleanColumnTupleSource.java
index 29add2b00b6..dd1b4017cdc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanByteColumnTupleSource.java
index b57258419f9..df87d155f03 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanCharacterColumnTupleSource.java
index f20cb6b17b4..a9ccd010571 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanColumnTupleSource.java
index defeece3a8b..4887ce077c7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final IntByteTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final IntByteTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntByteTuple, Integer, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanDoubleColumnTupleSource.java
index fbc4612724d..7fca5c23dd1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanFloatColumnTupleSource.java
index 3d9b4a48e1b..0e0b40c15af 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanInstantColumnTupleSource.java
index 35af072ce4b..65e61efb9c8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final IntByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final IntByteLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanIntegerColumnTupleSource.java
index aa70dda15cf..6e544f5e160 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanLongColumnTupleSource.java
index 9645929de00..ed52781d192 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanObjectColumnTupleSource.java
index d2ca4cc043f..d0bd1b836d4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index c2d16a78373..03795a7dac6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntByteByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 2f02cb2efe0..889a850843e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final IntByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final IntByteLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanShortColumnTupleSource.java
index 65b65283669..1d662ef7134 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntByteShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntByteShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantBooleanColumnTupleSource.java
index c8fbe51a431..8346a52216c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final IntLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final IntLongByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantByteColumnTupleSource.java
index 7643d2273be..12b2b829804 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantCharacterColumnTupleSource.java
index 8f7c51171e4..c18a3e61376 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantColumnTupleSource.java
index 866efb9f8e6..362187456d4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final IntLongTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final IntLongTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntLongTuple, Integer, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantDoubleColumnTupleSource.java
index fdba520580e..8a0da86cb0f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantFloatColumnTupleSource.java
index 7226834a24c..f2161fd191a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantInstantColumnTupleSource.java
index c34ee91202d..e01ba41a4f1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantIntegerColumnTupleSource.java
index 83680ae14c0..a989a58a77d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntLongIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntLongIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantLongColumnTupleSource.java
index 350abbcf17c..9ef9fb23474 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntLongLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantObjectColumnTupleSource.java
index c7b0325a1aa..da7d795f4c3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index f91b439d02b..e39776a471a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final IntLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final IntLongByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index cce3e4952db..ff7151ed163 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntLongLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantShortColumnTupleSource.java
index 85b9d6136c7..a52e3aef3c2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerReinterpretedInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntLongShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntLongShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortBooleanColumnTupleSource.java
index d41b8a425bd..5ff6981db36 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntShortByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntShortByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortByteColumnTupleSource.java
index bff48506271..182da3c2301 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntShortByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntShortByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortCharacterColumnTupleSource.java
index ceda272565c..adff7494744 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntShortCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntShortCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortColumnTupleSource.java
index f3cbad00b9b..00bb4614664 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortColumnTupleSource.java
@@ -76,6 +76,11 @@ public final IntShortTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final IntShortTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link IntegerShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<IntShortTuple, Integer, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortDoubleColumnTupleSource.java
index 20ea6254ce5..388093d19cd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntShortDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntShortDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortFloatColumnTupleSource.java
index ec463dedc30..189688d58d6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntShortFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntShortFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortInstantColumnTupleSource.java
index 822841d90cd..51fec101f1f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntShortLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntShortLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortIntegerColumnTupleSource.java
index 9a17b41c9df..233d96f6639 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntShortIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntShortIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortLongColumnTupleSource.java
index c9613239ed6..b0fa24c9762 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntShortLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntShortLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortObjectColumnTupleSource.java
index 25ef2354f45..ff7b02c8a37 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final IntShortObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final IntShortObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortReinterpretedBooleanColumnTupleSource.java
index 749059741b7..e3c4f41f940 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final IntShortByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final IntShortByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortReinterpretedInstantColumnTupleSource.java
index 23ddf297c9f..5501d4455f8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final IntShortLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final IntShortLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortShortColumnTupleSource.java
index 464dd0a5480..06483871b3d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/IntegerShortShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final IntShortShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final IntShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final IntShortShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final IntShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final IntShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final IntShortShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final IntShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanBooleanColumnTupleSource.java
index 54d4f113514..44947d16ae4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanByteColumnTupleSource.java
index d16b0f3c98a..f10487d33db 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanCharacterColumnTupleSource.java
index 37aa4447953..ff4327fa893 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanColumnTupleSource.java
index 495598053f6..6408b280526 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final LongByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final LongByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongByteTuple, Long, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanDoubleColumnTupleSource.java
index df942b50e39..c548927844a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanFloatColumnTupleSource.java
index 9bf0e7d2803..6b7748ab615 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanInstantColumnTupleSource.java
index 2051428a9af..186a52c59d5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanIntegerColumnTupleSource.java
index 62dc954bb26..b85fc37627a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanLongColumnTupleSource.java
index 61b4194c0ae..7074ee73f8b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanObjectColumnTupleSource.java
index 5aee0de178b..bdc4ed65a85 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanReinterpretedBooleanColumnTupleSource.java
index 6a65097b646..6736637e392 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanReinterpretedInstantColumnTupleSource.java
index 6d909d0c97e..146b025edcf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanShortColumnTupleSource.java
index 6b4099efe99..42dc42514a3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteBooleanColumnTupleSource.java
index 26b3e278b7c..709b1f7203c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteByteColumnTupleSource.java
index bd452af7122..794b868c2b2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteCharacterColumnTupleSource.java
index bbcce2bcf5a..6b4e31cec45 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteColumnTupleSource.java
index 781def9212f..45054fd00b5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteColumnTupleSource.java
@@ -76,6 +76,11 @@ public final LongByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final LongByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongByteTuple, Long, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteDoubleColumnTupleSource.java
index 49dc38f3d52..4c239f99f48 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteFloatColumnTupleSource.java
index 46f9c0a765d..8baddf2fdf6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteInstantColumnTupleSource.java
index 4e2e281bafd..7c20f94b0a1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteIntegerColumnTupleSource.java
index a5d6f906a57..ac444bb75e8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteLongColumnTupleSource.java
index b81ff70767f..dee43c70735 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteObjectColumnTupleSource.java
index 9699f39f5ed..d0c29365ff9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteReinterpretedBooleanColumnTupleSource.java
index a14445740b5..f2272055658 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteReinterpretedInstantColumnTupleSource.java
index 1f6cea4c5d1..a21f5a4c927 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteShortColumnTupleSource.java
index f4603fb1e5a..cb2cdd96a75 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongByteShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterBooleanColumnTupleSource.java
index d561c113340..2f9dbe8f1df 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterByteColumnTupleSource.java
index 453657296bc..85eef355ecc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterCharacterColumnTupleSource.java
index 803ec87e6f6..bf9fabcffcc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongCharCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongCharCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterColumnTupleSource.java
index 9753e966149..f4375e2d96b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterColumnTupleSource.java
@@ -76,6 +76,11 @@ public final LongCharTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final LongCharTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongCharTuple, Long, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterDoubleColumnTupleSource.java
index 55a3d970978..d06ef8cd0ba 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongCharDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterFloatColumnTupleSource.java
index bdbfdf691fb..a16b9fe0b49 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongCharFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongCharFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterInstantColumnTupleSource.java
index f7149771e6b..6590fdbed40 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterIntegerColumnTupleSource.java
index 13117cc04a6..ef57d71d21d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongCharIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongCharIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterLongColumnTupleSource.java
index cdffeeac901..0a78848a76e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterObjectColumnTupleSource.java
index 9ffed32f031..3c90f77a81d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongCharObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongCharObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterReinterpretedBooleanColumnTupleSource.java
index 0c6551b9d12..c41092baf31 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterReinterpretedInstantColumnTupleSource.java
index 8be501fd187..8dd1f1b823e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterShortColumnTupleSource.java
index 39a54840e36..95025c7b68f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongCharacterShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongCharShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongCharShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleBooleanColumnTupleSource.java
index 2c7926b7636..9ded9a41f9d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleByteColumnTupleSource.java
index bd5c46ea3e8..4690c82ca39 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleCharacterColumnTupleSource.java
index 8c9e8ebdd65..ea54fc8ac21 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongDoubleCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleColumnTupleSource.java
index 4e05fee4cb2..3f41b81d7f2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleColumnTupleSource.java
@@ -76,6 +76,11 @@ public final LongDoubleTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final LongDoubleTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongDoubleTuple, Long, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleDoubleColumnTupleSource.java
index 62eb8b19d9a..e3294eef572 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongDoubleDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleFloatColumnTupleSource.java
index 62c5567fe4c..62d039edd97 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongDoubleFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleInstantColumnTupleSource.java
index 130816fff04..14f7bf93fd2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleIntegerColumnTupleSource.java
index 63cbd8cd930..a1884ce1528 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongDoubleIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleLongColumnTupleSource.java
index 52f4ae23fd1..69fba8e2862 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleObjectColumnTupleSource.java
index 3c9f89186a0..853fd95ef45 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongDoubleObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleReinterpretedBooleanColumnTupleSource.java
index 61d0a0cf959..72f61310683 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleReinterpretedInstantColumnTupleSource.java
index d897e4d7ed3..e6fb2dbd116 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleShortColumnTupleSource.java
index 4071e4e3938..8049850cae1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongDoubleShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongDoubleShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongDoubleShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatBooleanColumnTupleSource.java
index 4b2c6f40261..840201e4499 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatByteColumnTupleSource.java
index 8af08e02cfc..1abb77644b5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatCharacterColumnTupleSource.java
index 96ab6f14a86..3618e255916 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongFloatCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongFloatCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatColumnTupleSource.java
index 169594468f7..45fa08a3a70 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatColumnTupleSource.java
@@ -76,6 +76,11 @@ public final LongFloatTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final LongFloatTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongFloatTuple, Long, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatDoubleColumnTupleSource.java
index 72db104d989..2d053323657 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongFloatDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatFloatColumnTupleSource.java
index d596f01a1f8..abf23b8d372 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongFloatFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatInstantColumnTupleSource.java
index 58be01e8aaa..561e3799114 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatIntegerColumnTupleSource.java
index 04fc9b96ffa..7edd1bdc6cd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongFloatIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongFloatIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatLongColumnTupleSource.java
index 958c3983bac..be80e499f5d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatObjectColumnTupleSource.java
index 687545e5835..58a45621fe4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongFloatObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongFloatObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatReinterpretedBooleanColumnTupleSource.java
index e5a75d5e97a..7ef162e46c6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatReinterpretedInstantColumnTupleSource.java
index e179a10c0cc..4ae262d6c3e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatShortColumnTupleSource.java
index e6fec918a4e..3017221d518 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongFloatShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongFloatShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongFloatShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantBooleanColumnTupleSource.java
index 6eca7b1389d..b8789b3d70d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantByteColumnTupleSource.java
index eba021fa6d9..8e11f14fccd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantCharacterColumnTupleSource.java
index e99853f1cb1..fc9957d2e28 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantColumnTupleSource.java
index f7c48757c76..f682c4bb9c6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongLongTuple, Long, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantDoubleColumnTupleSource.java
index 155e4f68ced..36c96a0468c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantFloatColumnTupleSource.java
index 9b6912b830e..bd227717b00 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantInstantColumnTupleSource.java
index 6926746831b..bd92f986fa0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantIntegerColumnTupleSource.java
index a702d183aeb..43817074b35 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantLongColumnTupleSource.java
index b22682fd391..004054d29d2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantObjectColumnTupleSource.java
index a1196052892..f3bb8839268 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantReinterpretedBooleanColumnTupleSource.java
index 68940826e7e..29f80832040 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantReinterpretedInstantColumnTupleSource.java
index 36fca9a5675..c78ba31b6c0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantShortColumnTupleSource.java
index 9a02482ba34..914876234f6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerBooleanColumnTupleSource.java
index 70e64e7f048..1a237fc71de 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerByteColumnTupleSource.java
index de977a370f5..9a03a3f30d2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerCharacterColumnTupleSource.java
index a3713940650..bd23934add2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongIntCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongIntCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerColumnTupleSource.java
index b1d013970d3..862b536475e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerColumnTupleSource.java
@@ -76,6 +76,11 @@ public final LongIntTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final LongIntTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongIntTuple, Long, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerDoubleColumnTupleSource.java
index 75a33eb49c4..56236b6953c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongIntDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerFloatColumnTupleSource.java
index e5c90f31a13..fbf00405dd6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongIntFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongIntFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerInstantColumnTupleSource.java
index 72b78c452ce..d130db25e9e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerIntegerColumnTupleSource.java
index d3234793ffe..91e6a771824 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongIntIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongIntIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerLongColumnTupleSource.java
index ba6776a4f3d..d9d8e9c9941 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerObjectColumnTupleSource.java
index d5cbc4d3230..9792439ae93 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongIntObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongIntObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerReinterpretedBooleanColumnTupleSource.java
index 74e56c2d403..916b1577c0e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerReinterpretedInstantColumnTupleSource.java
index 41289edaf06..6a4f25cb53d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerShortColumnTupleSource.java
index 469ec908f63..7c59b3c7dd4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongIntegerShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongIntShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongIntShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongBooleanColumnTupleSource.java
index 217eb97a34c..85fb035d917 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongByteColumnTupleSource.java
index 039e9fafcd5..6152a4233f7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongCharacterColumnTupleSource.java
index 61c52243ff3..0eb8cf8e9a1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongColumnTupleSource.java
index 6795b2e8785..189d48b5c66 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongColumnTupleSource.java
@@ -75,6 +75,11 @@ public final LongLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final LongLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongLongTuple, Long, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongDoubleColumnTupleSource.java
index 767d525c70c..3ec018e3f12 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongFloatColumnTupleSource.java
index 0941de80b87..c156fdc13e6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongInstantColumnTupleSource.java
index 80e3e686615..33e9a108835 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongIntegerColumnTupleSource.java
index 2b3911dd22c..0f45edeefce 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongLongColumnTupleSource.java
index 2a76878b432..65e5717f39a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongLongColumnTupleSource.java
@@ -82,6 +82,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongObjectColumnTupleSource.java
index 4fab3338132..1c32fb14f11 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongReinterpretedBooleanColumnTupleSource.java
index f6a89b03785..d0d1781b2db 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongReinterpretedInstantColumnTupleSource.java
index 607dbfb3c85..fc9dd60de1f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongReinterpretedInstantColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongShortColumnTupleSource.java
index 0ed6ba7c737..40554b8705c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongLongShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectBooleanColumnTupleSource.java
index b7d06d2f989..325c9d1165a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectByteColumnTupleSource.java
index 0c6285ff2ec..456ee3a701e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectCharacterColumnTupleSource.java
index 8263dab9df9..24c3b3884e0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongObjectCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongObjectCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectColumnTupleSource.java
index 8b49d6e5d91..1ba55d18588 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectColumnTupleSource.java
@@ -76,6 +76,11 @@ public final LongObjectTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final LongObjectTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongObjectTuple, Long, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectDoubleColumnTupleSource.java
index 18c85043de9..eadc06b6123 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongObjectDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectFloatColumnTupleSource.java
index f1132d574d7..de4543e09ef 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongObjectFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongObjectFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectInstantColumnTupleSource.java
index 95d585108bb..eea903597a4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectIntegerColumnTupleSource.java
index 5440d38864e..4209341207b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongObjectIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongObjectIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectLongColumnTupleSource.java
index 431eab39c38..2b493c1f019 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectObjectColumnTupleSource.java
index 41f3845c18f..1ac1a0ddc06 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongObjectObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongObjectObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectReinterpretedBooleanColumnTupleSource.java
index ecfed6610af..221784ac2ac 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectReinterpretedInstantColumnTupleSource.java
index 4beeeaf693b..a491d49b8db 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectShortColumnTupleSource.java
index 6e7f53877a3..69c69ab0dc0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongObjectShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongObjectShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongObjectShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanBooleanColumnTupleSource.java
index 00dff3ad97c..66de5c8580f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanByteColumnTupleSource.java
index 08a5eded4c8..c9cf8ca5003 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanCharacterColumnTupleSource.java
index 17c91ed0cda..19726d7b5fe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanColumnTupleSource.java
index 1dace686b79..1cb8739e6aa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final LongByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final LongByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongByteTuple, Long, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanDoubleColumnTupleSource.java
index 086e5edc5c0..4d7ca9aa135 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanFloatColumnTupleSource.java
index 4a31834aa4e..e0e292f60e5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanInstantColumnTupleSource.java
index 0f4858a3908..f19e55964c7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanIntegerColumnTupleSource.java
index dd192cdd18a..84a180794fa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanLongColumnTupleSource.java
index d1d8572bbc5..33ca6da9ffe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanObjectColumnTupleSource.java
index 7e8e41e2dd3..eeed380eb4c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 3201c1d83d8..16e149a17a2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 0fa7aedca24..6c72cca1392 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanShortColumnTupleSource.java
index 921ec0620d6..8c7aaeee209 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantBooleanColumnTupleSource.java
index bde83290908..3cee764964d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantByteColumnTupleSource.java
index 58c230daf4a..684110ed435 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantCharacterColumnTupleSource.java
index bff3805a5ba..105344ebfab 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantColumnTupleSource.java
index 76046ff8778..7c930a02dfb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantColumnTupleSource.java
@@ -77,6 +77,11 @@ public final LongLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final LongLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongLongTuple, Long, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantDoubleColumnTupleSource.java
index da21685eb3a..9b37e8bdfe0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantFloatColumnTupleSource.java
index c9f1aad5d44..f22cb58498d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantInstantColumnTupleSource.java
index d7d76c6e372..23c7b87425b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantIntegerColumnTupleSource.java
index a4d2bd2e027..0eabff148d0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantLongColumnTupleSource.java
index 61f63094710..0468938b0b2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantObjectColumnTupleSource.java
index 4774e7b3819..f11f4f415f8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index 0131b5522a4..3493f9f20a6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index 797f9a2ea16..6ba3f036d5b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantShortColumnTupleSource.java
index aad03b701f7..ac4c473d901 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongReinterpretedInstantShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortBooleanColumnTupleSource.java
index 81bd05a95d9..21b90fca98c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortByteColumnTupleSource.java
index 08f147adfa5..0f0b95da55a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortCharacterColumnTupleSource.java
index 1d99e554543..0ac0fa90030 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongShortCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongShortCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortColumnTupleSource.java
index e2c0f9117c2..69b6d554c75 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortColumnTupleSource.java
@@ -76,6 +76,11 @@ public final LongShortTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final LongShortTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link LongShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongShortTuple, Long, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortDoubleColumnTupleSource.java
index efb9167aede..310161a23fb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongShortDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongShortDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortFloatColumnTupleSource.java
index ee3679db85d..4112a9fa008 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongShortFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongShortFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortInstantColumnTupleSource.java
index 4c40ba577e5..d65096bcbb8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortIntegerColumnTupleSource.java
index 135e1d72e7d..11feb8a850d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongShortIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongShortIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortLongColumnTupleSource.java
index 5675bbd9f64..75e09f6b2db 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortObjectColumnTupleSource.java
index 90988226adb..83d40232e16 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongShortObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongShortObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortReinterpretedBooleanColumnTupleSource.java
index 87a4a16c469..59e45d49f51 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortReinterpretedInstantColumnTupleSource.java
index 87439103668..d8af0119916 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortShortColumnTupleSource.java
index 21157458ba7..d85ef2a31c7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/LongShortShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final LongShortShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final LongShortShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanBooleanColumnTupleSource.java
index 2f6ee097971..a871f76cadd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanBooleanColumnTupleSource.java
@@ -82,6 +82,11 @@ public final ObjectByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final ObjectByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanByteColumnTupleSource.java
index 5f90d78f222..22656e6f65e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanCharacterColumnTupleSource.java
index 870ef441838..6d07e698b42 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanColumnTupleSource.java
index 449e64c91d6..5fa3e0c14e8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanColumnTupleSource.java
@@ -75,6 +75,11 @@ public final ObjectByteTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final ObjectByteTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectByteTuple, Object, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanDoubleColumnTupleSource.java
index 207d1f84df9..5babac1541d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanFloatColumnTupleSource.java
index bdb207e1d9e..b2d1c26238e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanInstantColumnTupleSource.java
index 54789382a9a..0d392ceedb4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanInstantColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanIntegerColumnTupleSource.java
index f8ef81006d9..6632b08ae84 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanLongColumnTupleSource.java
index 1c6e4aaff60..386901cd593 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanObjectColumnTupleSource.java
index 296d194d1ad..0d548449fe6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanObjectColumnTupleSource.java
@@ -82,6 +82,11 @@ public final ObjectByteObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final ObjectByteObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanReinterpretedBooleanColumnTupleSource.java
index d6d3479b531..603df2fa40c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanReinterpretedInstantColumnTupleSource.java
index d0643960fed..9ce2e71b50c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanShortColumnTupleSource.java
index a0aa3fd49ee..4541251b1b0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectBooleanShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteBooleanColumnTupleSource.java
index 1634057cb8b..534ac63a59c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteByteColumnTupleSource.java
index fa0cb85ac3c..f16b81b12f0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteCharacterColumnTupleSource.java
index 821c6efa964..06a7e478906 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteColumnTupleSource.java
index 07e6002afba..d2c9cac197e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ObjectByteTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ObjectByteTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectByteTuple, Object, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteDoubleColumnTupleSource.java
index 9bb2fce920b..e1b0255bb8e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteFloatColumnTupleSource.java
index 8e168160884..75715393c37 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteInstantColumnTupleSource.java
index a1193c47b9f..bf65d1e7c50 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteIntegerColumnTupleSource.java
index a6f93b87397..5ce092476ee 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteLongColumnTupleSource.java
index cbeb056f3c6..bfae07b7c7f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteObjectColumnTupleSource.java
index 6c91fe27b61..d25254a0297 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectByteObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectByteObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteReinterpretedBooleanColumnTupleSource.java
index 6d873b9a087..7dcaece5dcc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteReinterpretedInstantColumnTupleSource.java
index 93937dc0f9d..4c8c859f7d1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteShortColumnTupleSource.java
index 83b02094776..489563dcf7e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectByteShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterBooleanColumnTupleSource.java
index 9712bf86628..224a330ec80 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectCharByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectCharByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterByteColumnTupleSource.java
index 523cc3a88f3..ee6416e4de1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectCharByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectCharByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterCharacterColumnTupleSource.java
index c435e2e41ca..10e51fc8480 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectCharCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectCharCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterColumnTupleSource.java
index a80c84e4993..6db603e6ca6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ObjectCharTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ObjectCharTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectCharTuple, Object, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterDoubleColumnTupleSource.java
index 7a9654294a6..109d5095df1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectCharDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectCharDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterFloatColumnTupleSource.java
index e73142ba462..8c02133ce93 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectCharFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectCharFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterInstantColumnTupleSource.java
index 980c3e2f07d..ba918aabce2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectCharLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectCharLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterIntegerColumnTupleSource.java
index 118fc43798b..77747845f69 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectCharIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectCharIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterLongColumnTupleSource.java
index f2e7871eeb5..8d47055fb46 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectCharLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectCharLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterObjectColumnTupleSource.java
index 7ec24b367c9..556b0fa89b4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectCharObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectCharObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterReinterpretedBooleanColumnTupleSource.java
index eeb61a10e6b..15d2d3f6057 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectCharByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectCharByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterReinterpretedInstantColumnTupleSource.java
index e15190796f9..9ecab93dbbc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectCharLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectCharLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterShortColumnTupleSource.java
index 878e893762c..53b93f4a9c3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectCharacterShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectCharShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectCharShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectCharShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleBooleanColumnTupleSource.java
index fb5b29a21ac..41097ce4236 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectDoubleByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectDoubleByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleByteColumnTupleSource.java
index 6c7ba7053df..43223707730 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectDoubleByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectDoubleByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleCharacterColumnTupleSource.java
index bb98b89200e..733f34c4e6a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectDoubleCharTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectDoubleCharTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleCharTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleColumnTupleSource.java
index f3c65e8420f..0309c0905b1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ObjectDoubleTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectDoubleTuple, Object, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleDoubleColumnTupleSource.java
index 9613ed381f0..db9a74b1a0b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectDoubleDoubleTuple tuple,
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleDouble
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleFloatColumnTupleSource.java
index f187bb86fce..bdf2e6ca3e7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectDoubleFloatTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleFloatT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleInstantColumnTupleSource.java
index 443fee72544..d5899a0e37b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectDoubleLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectDoubleLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleIntegerColumnTupleSource.java
index 096fb546545..7ca25cc24d5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectDoubleIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleIntTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleLongColumnTupleSource.java
index db0c7957c27..e8563fe4d17 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectDoubleLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectDoubleLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleObjectColumnTupleSource.java
index 03f1a0e234f..b3ce691907f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectDoubleObjectTuple tuple,
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleObject
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleReinterpretedBooleanColumnTupleSource.java
index 0b6fb6d518f..4f835098bb1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectDoubleByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectDoubleByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleReinterpretedInstantColumnTupleSource.java
index dd30996f1cc..95a127e3a19 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectDoubleLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectDoubleLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleShortColumnTupleSource.java
index d9654c6bbe5..f42bf7fca0f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectDoubleShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectDoubleShortTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectDoubleShortTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectDoubleShortT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatBooleanColumnTupleSource.java
index 4418d50cc7d..dfc74e7f148 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectFloatByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatByteColumnTupleSource.java
index 5af49fe21d2..c12e8138b65 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectFloatByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatCharacterColumnTupleSource.java
index c3cde5c746c..0487b2148ea 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectFloatCharTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectFloatCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatCharTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatColumnTupleSource.java
index 1a90d8a5879..f3d855f3fef 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ObjectFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ObjectFloatTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectFloatTuple, Object, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatDoubleColumnTupleSource.java
index 39c803c9939..1bc4af05030 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectFloatDoubleTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatDoubleT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatFloatColumnTupleSource.java
index 1a649c50fff..1ae8a7f097a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectFloatFloatTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectFloatFloatTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatFloatTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatInstantColumnTupleSource.java
index 19f70d3b72b..dced60e487a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectFloatLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatIntegerColumnTupleSource.java
index 081ab2e7377..217df516957 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectFloatIntTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectFloatIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatIntTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatLongColumnTupleSource.java
index 7811bce18e3..a77d0991fb3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectFloatLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatObjectColumnTupleSource.java
index 649e558dde4..7558fd3c3d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectFloatObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectFloatObjectTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatObjectT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatReinterpretedBooleanColumnTupleSource.java
index a5cbc2f6504..410b817eb1b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectFloatByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatReinterpretedInstantColumnTupleSource.java
index 085f2df61fe..45f5b47bdde 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectFloatLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatShortColumnTupleSource.java
index 262042a001a..7008ce5b0c7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectFloatShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectFloatShortTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectFloatShortTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectFloatShortTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantBooleanColumnTupleSource.java
index cfc1dfc26a6..58d8e062771 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantByteColumnTupleSource.java
index 5b34c905e06..94163d9d5af 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantCharacterColumnTupleSource.java
index 78194da9dc9..cee3688be2c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantColumnTupleSource.java
index b077dc90fa5..09d72d63a41 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ObjectLongTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ObjectLongTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectLongTuple, Object, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantDoubleColumnTupleSource.java
index d25bbff46ff..1e06c91d50c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantFloatColumnTupleSource.java
index 4b457b1776d..771b66e89e4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantInstantColumnTupleSource.java
index 307db9e9fa1..7d1a9ccf1a2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantInstantColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantIntegerColumnTupleSource.java
index 28a54be4e03..4be038b6bf7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantLongColumnTupleSource.java
index 14fbaa3e339..8441695c5da 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantObjectColumnTupleSource.java
index 97852f249b6..93fce98cd15 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectLongObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectLongObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantReinterpretedBooleanColumnTupleSource.java
index 9cfe2e2d2fd..e73919f53d3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantReinterpretedInstantColumnTupleSource.java
index 81ad5a7da71..ca7a9864bad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantShortColumnTupleSource.java
index bcb6ce4e6c6..1877502470e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectInstantShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerBooleanColumnTupleSource.java
index d264e9796df..4d0615e07a3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectIntByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectIntByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerByteColumnTupleSource.java
index d4ae40dffcd..a920e65c6f0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectIntByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectIntByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerCharacterColumnTupleSource.java
index ac9bca5b966..9a090731f51 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectIntCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectIntCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerColumnTupleSource.java
index aee26113506..79eb374343f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ObjectIntTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ObjectIntTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectIntTuple, Object, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerDoubleColumnTupleSource.java
index 53900632dfc..d9f08e559ba 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectIntDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerFloatColumnTupleSource.java
index cdcd795616e..59df28d4f04 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectIntFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectIntFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerInstantColumnTupleSource.java
index 6e16f72d559..a59158761a0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectIntLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectIntLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerIntegerColumnTupleSource.java
index cab917b6328..ab8ff32ea32 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectIntIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectIntIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerLongColumnTupleSource.java
index c25f39819f2..79045dc91eb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectIntLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectIntLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerObjectColumnTupleSource.java
index a93d608bd38..64d8ac231ef 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectIntObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectIntObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerReinterpretedBooleanColumnTupleSource.java
index 580f27bb114..18453c43ae3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectIntByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectIntByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerReinterpretedInstantColumnTupleSource.java
index b6f1e705465..18f2dbd9ac0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectIntLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectIntLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerShortColumnTupleSource.java
index fc8c00fbc0f..2092503ccb8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectIntegerShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectIntShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectIntShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectIntShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongBooleanColumnTupleSource.java
index 9f5c3a28ccc..0acb0be2817 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongByteColumnTupleSource.java
index 722ebc676b6..b82a4fc0511 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongCharacterColumnTupleSource.java
index eed494db567..36c520191c6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectLongCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectLongCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongColumnTupleSource.java
index 8b892094bd4..1076cdc8a57 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ObjectLongTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ObjectLongTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectLongTuple, Object, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongDoubleColumnTupleSource.java
index 9c45399f867..11510158d46 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectLongDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectLongDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongFloatColumnTupleSource.java
index c5ecd8f8e68..6069e8f5f4e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectLongFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongInstantColumnTupleSource.java
index 89369a4f1b4..4e8450a3cc6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongIntegerColumnTupleSource.java
index dc417710610..287fd1b25ef 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectLongIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectLongIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongLongColumnTupleSource.java
index feb0302a789..2f711491326 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongObjectColumnTupleSource.java
index c18fd149e6b..1083d56731a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectLongObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectLongObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongReinterpretedBooleanColumnTupleSource.java
index b2034729733..ce96aa0f7b1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongReinterpretedInstantColumnTupleSource.java
index b24f22a9c50..70245e6cc4c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongShortColumnTupleSource.java
index 8a93f06ea03..5a9d84e213a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectLongShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectLongShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectBooleanColumnTupleSource.java
index 9f4e62d42a4..a9dc06407c6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectBooleanColumnTupleSource.java
@@ -82,6 +82,11 @@ public final ObjectObjectByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final ObjectObjectByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectByteColumnTupleSource.java
index 84b6054d7ca..7f939c87838 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectObjectByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectObjectByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectCharacterColumnTupleSource.java
index e2a021ad41a..1606ed046cd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectObjectCharTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectObjectCharTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectCharTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectColumnTupleSource.java
index 167c90a4fd7..fbfd19bc104 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectColumnTupleSource.java
@@ -74,6 +74,11 @@ public final ObjectObjectTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -99,6 +104,18 @@ public final Object exportElement(@NotNull final ObjectObjectTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -120,6 +137,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectObjectTuple, Object, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectDoubleColumnTupleSource.java
index 790ff353e09..7c09ec98ea7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectObjectDoubleTuple tuple,
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectDouble
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectFloatColumnTupleSource.java
index d8c33cb2297..219110ae520 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectObjectFloatTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectObjectFloatTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectFloatT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectInstantColumnTupleSource.java
index defe461e084..7ce32d1e68d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectInstantColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectObjectLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectObjectLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectIntegerColumnTupleSource.java
index 92661c4b863..322a7ad5886 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectObjectIntTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectObjectIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectIntTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectLongColumnTupleSource.java
index ff20edc8148..dbae276af22 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectObjectLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectObjectLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectObjectColumnTupleSource.java
index 287760c8986..7b6d1fc29da 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectObjectColumnTupleSource.java
@@ -81,6 +81,11 @@ public final ObjectObjectObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -113,6 +118,20 @@ public final Object exportElement(@NotNull final ObjectObjectObjectTuple tuple,
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -126,6 +145,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectObject
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectReinterpretedBooleanColumnTupleSource.java
index 47971038b98..69f06783176 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectObjectByteTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectObjectByteTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectByteTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectReinterpretedInstantColumnTupleSource.java
index 81f32598600..9a1e042699f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectObjectLongTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectObjectLongTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectLongTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectShortColumnTupleSource.java
index 257f4247c54..6cb9b1a1083 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectObjectShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectObjectShortTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectObjectShortTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectObjectShortT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanBooleanColumnTupleSource.java
index 56f2b6e0a91..dcd6ef03b9c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanByteColumnTupleSource.java
index 7ea39b74602..060f6da4238 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanCharacterColumnTupleSource.java
index c262b9b90ab..b43bd53292d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectByteCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectByteCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanColumnTupleSource.java
index 60c17cf4505..41d4e7ceb3b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ObjectByteTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ObjectByteTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectByteTuple, Object, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanDoubleColumnTupleSource.java
index 4782fd16c59..a513f71e182 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectByteDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectByteDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanFloatColumnTupleSource.java
index 0618bac977c..b477948473d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectByteFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanInstantColumnTupleSource.java
index cf3fc34a152..19dfe028d0e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanIntegerColumnTupleSource.java
index 1333a86273e..97864067e5d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectByteIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectByteIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanLongColumnTupleSource.java
index 5115f827da8..badec30dd6b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanObjectColumnTupleSource.java
index a492e43208d..85a9ae56757 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 2e5d70abb30..1699d1adcc4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectByteByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectByteByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 7d4f7dcc007..8365577ea5d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ObjectByteLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ObjectByteLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanShortColumnTupleSource.java
index 662b9048839..3749e4d74eb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectByteShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectByteShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantBooleanColumnTupleSource.java
index 38e244e77ff..976afa17409 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantByteColumnTupleSource.java
index 011399848f9..c872bc20d2d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantCharacterColumnTupleSource.java
index a3df46e4aa3..76404836d3e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectLongCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectLongCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantColumnTupleSource.java
index f97b7ef52e0..471771e56c7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final ObjectLongTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final ObjectLongTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectLongTuple, Object, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantDoubleColumnTupleSource.java
index 6b8450774fa..3dfcdead31b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectLongDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectLongDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantFloatColumnTupleSource.java
index 90a7b33aca5..3bc0f67c13a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectLongFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantInstantColumnTupleSource.java
index 3e6c9d6183a..da082b4bd15 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantIntegerColumnTupleSource.java
index 1069732fdfe..e10fb388819 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectLongIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectLongIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantLongColumnTupleSource.java
index 87b0298236d..d56164a4c1e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantObjectColumnTupleSource.java
index bc4b7081b28..b9173af7d33 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index 011b3e1101d..e18df2f32ff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ObjectLongByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ObjectLongByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index 1afcdcbb7f2..100db05f98a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectLongLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectLongLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantShortColumnTupleSource.java
index 562334842b9..3311f095b86 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectReinterpretedInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectLongShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectLongShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortBooleanColumnTupleSource.java
index 033dd51de1f..0f9cbe3f3ed 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectShortByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortByteColumnTupleSource.java
index 3b030ced1f0..29f6688f580 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectShortByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortCharacterColumnTupleSource.java
index 5f72b8ba619..0d3a69f529d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectShortCharTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectShortCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortCharTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortCharTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortColumnTupleSource.java
index 250a3c0bc12..53f2c22a190 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ObjectShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ObjectShortTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ObjectShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ObjectShortTuple, Object, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortDoubleColumnTupleSource.java
index 06a66c2860d..4e1f84efb64 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectShortDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectShortDoubleTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortDoubleT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortDoubleTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortFloatColumnTupleSource.java
index 7673b47dc8e..902aed3b018 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectShortFloatTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectShortFloatTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortFloatTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortFloatTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortInstantColumnTupleSource.java
index 20f42af2dd5..aab9ccbf883 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectShortLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortIntegerColumnTupleSource.java
index 595737139e1..3952a422eec 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectShortIntTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectShortIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortIntTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortIntTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortLongColumnTupleSource.java
index 1d96e9c65e1..e030668a51e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ObjectShortLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ObjectShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortObjectColumnTupleSource.java
index 1b28fa35525..ef501286df1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectShortObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectShortObjectTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortObjectT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortObjectTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortReinterpretedBooleanColumnTupleSource.java
index d0b1c52bc15..08d6f1dae95 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ObjectShortByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ObjectShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortReinterpretedInstantColumnTupleSource.java
index b9a8ede6420..03d9561fc37 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ObjectShortLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ObjectShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortShortColumnTupleSource.java
index c7403639598..cccdbad8480 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ObjectShortShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ObjectShortShortTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ObjectShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ObjectShortShortTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ObjectShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ObjectShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ObjectShortShortTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortShortTuple tuple) {
+        dest[0] = tuple.getFirstElement();
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ObjectShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = tuple.getFirstElement();
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanBooleanColumnTupleSource.java
index ba6bfd31e83..51a896bcdff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanByteColumnTupleSource.java
index 6f3baf0b0c9..2c953b40c8a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanCharacterColumnTupleSource.java
index f0312d1f9cb..5c86225f04c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanColumnTupleSource.java
index 2d98cf528e3..a212f3787b7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteByteTuple, Byte, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanDoubleColumnTupleSource.java
index ef8fd0dc6ff..f3f932cc36e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanFloatColumnTupleSource.java
index 6dfa0d69391..f49ac6f14b5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanInstantColumnTupleSource.java
index bf0e159dfad..3f0ae19fe71 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanIntegerColumnTupleSource.java
index 61fe3dcba7b..f5ddd5eeb37 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanLongColumnTupleSource.java
index 80b2cdd9c38..dc316e12b6e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanObjectColumnTupleSource.java
index eb962b7fed8..e34509a5db7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanReinterpretedBooleanColumnTupleSource.java
index b207f511e8d..1b8eb2e8c1c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanReinterpretedInstantColumnTupleSource.java
index b7ea1015635..d73b8b4bb96 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanShortColumnTupleSource.java
index 98afd1998e1..dc7f0f01621 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanBooleanShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteBooleanColumnTupleSource.java
index 6b7a9a0591e..afb0203220d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteByteColumnTupleSource.java
index 316cad1aedc..7aa2e1a44a7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteCharacterColumnTupleSource.java
index 8f25273454b..c26eb71676a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteColumnTupleSource.java
index 4cbd0e39d38..ed52ac6d49a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteByteTuple, Byte, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteDoubleColumnTupleSource.java
index 74269ca8463..7248e973499 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteFloatColumnTupleSource.java
index 97103de279b..b435b82db15 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteInstantColumnTupleSource.java
index a3c54cb67e1..7a08fbc1ca5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteIntegerColumnTupleSource.java
index a4b2f093b16..f25c7535ce0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteLongColumnTupleSource.java
index f5c36b36b61..dae0799af8c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteObjectColumnTupleSource.java
index 63408c942c9..22cf76ba39d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteReinterpretedBooleanColumnTupleSource.java
index 057a3e8195e..ccbdadf3ea9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteReinterpretedBooleanColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteReinterpretedInstantColumnTupleSource.java
index f1bd7f73e31..d1b2068a371 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteShortColumnTupleSource.java
index 0f1ad2d25bf..4d420c2061c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanByteShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterBooleanColumnTupleSource.java
index aa9fded6554..704c448dc57 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterByteColumnTupleSource.java
index bfd9a48dd3b..5f50e451eec 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterCharacterColumnTupleSource.java
index 54cca5e92ff..ceec0e74997 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterColumnTupleSource.java
index f4d27c444b8..0e3931c4717 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteCharTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteCharTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteCharTuple, Byte, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterDoubleColumnTupleSource.java
index d30ad1980ee..e32d543ecce 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterFloatColumnTupleSource.java
index 7e9e0706f31..4d5af15f72f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterInstantColumnTupleSource.java
index 9c3a31becca..2664b698ffb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterIntegerColumnTupleSource.java
index a1bdffafae1..22447b7790f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterLongColumnTupleSource.java
index e921d4460ce..d8b1fe07015 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterObjectColumnTupleSource.java
index 323d12f9ad2..0fdf7d6e1e6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterReinterpretedBooleanColumnTupleSource.java
index f59dea28423..13e7a3a0020 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterReinterpretedInstantColumnTupleSource.java
index 7160c5c7c90..ac2a368bf2e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterShortColumnTupleSource.java
index 19a4ebc4a1b..ed4c67ef0e0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanCharacterShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteCharShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteCharShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteCharShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleBooleanColumnTupleSource.java
index 263d3d9a310..8c160e60943 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleByteColumnTupleSource.java
index 6eaefa4e4f1..1df7c3b8c81 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleCharacterColumnTupleSource.java
index 6c01dfebc3d..3862b6d2235 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleColumnTupleSource.java
index 8bba9fb4600..1d349a27dd5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteDoubleTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteDoubleTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteDoubleTuple, Byte, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleDoubleColumnTupleSource.java
index acbfd57faeb..8222d9c665a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleFloatColumnTupleSource.java
index a3f8ca47e1d..2acf6bdb381 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleInstantColumnTupleSource.java
index 4d70f33dbde..f2e63c6f79b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleIntegerColumnTupleSource.java
index 8ec29008450..bd99e7a7d86 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleLongColumnTupleSource.java
index 0a0df6d626b..420e20dbf80 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleObjectColumnTupleSource.java
index d9c2c55f027..c72f77c36b0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleReinterpretedBooleanColumnTupleSource.java
index df535befaff..100f355d4c4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleReinterpretedInstantColumnTupleSource.java
index d3ed95070b5..b7037e7fb49 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleShortColumnTupleSource.java
index ee15abc7c3e..680cbd021c3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanDoubleShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteDoubleShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteDoubleShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteDoubleShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatBooleanColumnTupleSource.java
index a93e52f4608..9946027041c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatByteColumnTupleSource.java
index e6e3827df4a..5308784f36c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatCharacterColumnTupleSource.java
index 849e45053de..d4fbb6c1b84 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatColumnTupleSource.java
index cc6f4688b6d..510302a2919 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteFloatTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteFloatTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteFloatTuple, Byte, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatDoubleColumnTupleSource.java
index bafea15d05d..303b32edbee 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatFloatColumnTupleSource.java
index 6bddcad98b9..abcfedfe0bf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatInstantColumnTupleSource.java
index 29dbdbf9651..37590061161 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatIntegerColumnTupleSource.java
index 0b472b8363b..bac1b35d3b2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatLongColumnTupleSource.java
index 9d726e37691..8fa264dc58a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatObjectColumnTupleSource.java
index eb65f282748..1c499602a3e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatReinterpretedBooleanColumnTupleSource.java
index 714142c4dce..ad3f332cc1e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatReinterpretedInstantColumnTupleSource.java
index 9d5541e3946..c87bd6dd78f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatShortColumnTupleSource.java
index b87df087402..835de4f5a8c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanFloatShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteFloatShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteFloatShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteFloatShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantBooleanColumnTupleSource.java
index 361e51243c2..61bf48ac78e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantByteColumnTupleSource.java
index 4393b6c6372..142ae02b4ad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantCharacterColumnTupleSource.java
index b34be38c6d6..3a10d3521d2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantCharacterColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantColumnTupleSource.java
index b6b7cecf25d..bf30dd25303 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantColumnTupleSource.java
@@ -79,6 +79,11 @@ public final ByteLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -104,6 +109,18 @@ public final Object exportElement(@NotNull final ByteLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -125,6 +142,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteLongTuple, Byte, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantDoubleColumnTupleSource.java
index eda2107b3ec..290d815fe28 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantDoubleColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantFloatColumnTupleSource.java
index cbb113ed7af..b26ee7cde63 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantFloatColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantInstantColumnTupleSource.java
index 84c9a4edf43..615715a413b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantIntegerColumnTupleSource.java
index 03e4d17c2ee..c3e1e95fdda 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantIntegerColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantLongColumnTupleSource.java
index 18ed11a62cb..8dc6b6ca774 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantLongColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantObjectColumnTupleSource.java
index 583576840a1..3e0105db074 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantReinterpretedBooleanColumnTupleSource.java
index 3ce9cca1693..435e638bb76 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantReinterpretedInstantColumnTupleSource.java
index 81442f97c36..00a33388c00 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantShortColumnTupleSource.java
index 00afb4abd69..b6699bc02d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanInstantShortColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerBooleanColumnTupleSource.java
index 1e1ca1dc707..1d3894ee9c9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerByteColumnTupleSource.java
index 49455753cef..16c47c86809 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerCharacterColumnTupleSource.java
index 00b26642899..6ac21408c67 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerColumnTupleSource.java
index a87e6198b72..0f81fe52789 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteIntTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteIntTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteIntTuple, Byte, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerDoubleColumnTupleSource.java
index 1dcbf2bdb3e..a0cda25405f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerFloatColumnTupleSource.java
index 3f68d09edeb..806965519d1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerInstantColumnTupleSource.java
index 3da7807d412..e8b148a9229 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerIntegerColumnTupleSource.java
index 5feb9c5b952..c1e0b7089d1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerLongColumnTupleSource.java
index 7f21ce03c03..a7b30900ffd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerObjectColumnTupleSource.java
index 66407cc70ec..039bd896b2b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerReinterpretedBooleanColumnTupleSource.java
index 9ef5ec83af6..dd9ab0d873f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerReinterpretedInstantColumnTupleSource.java
index 483894e8912..d751b483633 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerShortColumnTupleSource.java
index d22ce1eb8a9..e8120b2c856 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanIntegerShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteIntShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteIntShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteIntShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongBooleanColumnTupleSource.java
index 714e07c2297..c6e73e3024a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongByteColumnTupleSource.java
index 2ac2c382694..98f331f917a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongCharacterColumnTupleSource.java
index 2e038df6d98..42c8330734b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongColumnTupleSource.java
index 42225963b4f..76640de6564 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteLongTuple, Byte, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongDoubleColumnTupleSource.java
index 9a5bbef8a03..d6b135b4ddf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongFloatColumnTupleSource.java
index 6aa3d4985ad..0f2c5e4c30f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongInstantColumnTupleSource.java
index 90a84d9303a..a4317f635a1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongIntegerColumnTupleSource.java
index 87bec148489..1aa88216fcb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongLongColumnTupleSource.java
index 68d96634c6e..a020c59af0e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongObjectColumnTupleSource.java
index dd453e7276d..702568a3884 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongReinterpretedBooleanColumnTupleSource.java
index c2ec9ad23b0..fb08dbf6094 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongReinterpretedInstantColumnTupleSource.java
index 229b1eb48d4..35557850039 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongShortColumnTupleSource.java
index 663bf72875d..aa42bab283b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanLongShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectBooleanColumnTupleSource.java
index ea269b4d4bf..373951da301 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectByteColumnTupleSource.java
index 129d05f3b2e..d14c10533d6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectCharacterColumnTupleSource.java
index fa7a935f0b3..b70dac23904 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteObjectCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteObjectCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectColumnTupleSource.java
index 655bcab82f9..20ee1382cb1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteObjectTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteObjectTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteObjectTuple, Byte, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectDoubleColumnTupleSource.java
index e8f9dabbaf7..949262fc35e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteObjectDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectFloatColumnTupleSource.java
index 298d1a1ec6a..f331448a7c9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteObjectFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteObjectFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectInstantColumnTupleSource.java
index 8337e2dfa93..b32041e83af 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectIntegerColumnTupleSource.java
index c6928ebe004..118e62c5970 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteObjectIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteObjectIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectLongColumnTupleSource.java
index 12309276b85..69a940a4900 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectObjectColumnTupleSource.java
index 3394a2505a7..6b8dd0cef1c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectReinterpretedBooleanColumnTupleSource.java
index 4f99a8435c2..61ee2b632e3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectReinterpretedInstantColumnTupleSource.java
index 3377e6d5750..02761a5c8bf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectShortColumnTupleSource.java
index 7b24fa1af6d..9736d9ff4f5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanObjectShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteObjectShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteObjectShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteObjectShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanBooleanColumnTupleSource.java
index 0b3bd47891b..eccd58f2abc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanByteColumnTupleSource.java
index 1fd2733de55..9f054ab7a93 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanCharacterColumnTupleSource.java
index 456cca833b4..c7b89dbfb7b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 5c1a74d1382..ca68ae81d9d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ByteByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ByteByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteByteTuple, Byte, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanDoubleColumnTupleSource.java
index bf69ccff58e..c9643a26718 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanFloatColumnTupleSource.java
index fe61721d541..c7c957de0c8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanInstantColumnTupleSource.java
index a86bc2fa6d4..1fcaa1a47e9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanIntegerColumnTupleSource.java
index ebadc812d85..0d47089bf88 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanLongColumnTupleSource.java
index e4703825230..281ffc0654f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanObjectColumnTupleSource.java
index 4c0fdd308cc..56dc5216d96 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 559e4b86f1f..c4a05adfde4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ByteByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ByteByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 13ca2ffc299..7b816e18522 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanShortColumnTupleSource.java
index b4c47b23fa8..8dbbd3eddbf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedBooleanShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantBooleanColumnTupleSource.java
index 2fb31fe6295..448c53c889f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantByteColumnTupleSource.java
index 51aaa13ca35..209c41fc78c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantCharacterColumnTupleSource.java
index a44ba4624c0..33613b9cb9f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantCharacterColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index b197d016a87..5f496820aae 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -79,6 +79,11 @@ public final ByteLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -104,6 +109,18 @@ public final Object exportElement(@NotNull final ByteLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -125,6 +142,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteLongTuple, Byte, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantDoubleColumnTupleSource.java
index d6935b774ad..cf5bebaf493 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantDoubleColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantFloatColumnTupleSource.java
index fdab7242e69..6ac9f89734c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantFloatColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantInstantColumnTupleSource.java
index d65a9db9bf5..02ca70dbf40 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantIntegerColumnTupleSource.java
index 540dcedc34e..4fcd32fbfee 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantIntegerColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantLongColumnTupleSource.java
index 30a4672dbe0..8d4f6b6ea93 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantObjectColumnTupleSource.java
index b4d91311af9..315cb1af6b1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantObjectColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index 8e235655c82..b8a5a8ded6d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index d98f3fee384..c7ad27064e2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ByteLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ByteLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantShortColumnTupleSource.java
index 2c555a1dcca..3bd6a9db8b0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanReinterpretedInstantShortColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortBooleanColumnTupleSource.java
index 33f1a51426a..bf7e61cd524 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortByteColumnTupleSource.java
index 01003ee4983..66a22005e4b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortCharacterColumnTupleSource.java
index 135ec506675..b0cbb5dcc8c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortColumnTupleSource.java
index 9dd19623633..d568130a862 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ByteShortTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ByteShortTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedBooleanShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ByteShortTuple, Byte, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortDoubleColumnTupleSource.java
index ee7c68b18e3..2cf7ee165b4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortFloatColumnTupleSource.java
index 41a7fce8ca4..d24038138a9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortInstantColumnTupleSource.java
index 0369198cfeb..8e1aaf0b6e9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortIntegerColumnTupleSource.java
index 3591bfa1217..1d3ad549db3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortLongColumnTupleSource.java
index 4f7f75da3d9..ee0965de440 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortObjectColumnTupleSource.java
index f3b72f73ddd..3426c73b687 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ByteShortObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ByteShortObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortReinterpretedBooleanColumnTupleSource.java
index 26e06cedb3e..63d08c1779c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortReinterpretedInstantColumnTupleSource.java
index 75e26282c4f..a4fdda61c9c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ByteShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ByteShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortShortColumnTupleSource.java
index fdbad032502..fc122ef177b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedBooleanShortShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ByteShortShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ByteShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ByteShortShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple) {
+        dest[0] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = BooleanUtils.byteAsBoolean(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ByteShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ByteShortShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ByteShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanBooleanColumnTupleSource.java
index 7eb5e5cc44f..03d44535c0a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanByteColumnTupleSource.java
index e8b5b7a4665..241534f34ee 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanByteColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanCharacterColumnTupleSource.java
index e26feef3a21..612d1297f32 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanCharacterColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanColumnTupleSource.java
index 83d1aeb2661..5172d36bd61 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanColumnTupleSource.java
@@ -79,6 +79,11 @@ public final LongByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -104,6 +109,18 @@ public final Object exportElement(@NotNull final LongByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -125,6 +142,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongByteTuple, Long, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanDoubleColumnTupleSource.java
index 080ece00857..0a22c5c2e01 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanDoubleColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanFloatColumnTupleSource.java
index 02d206a470f..45624e73a89 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanFloatColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanInstantColumnTupleSource.java
index b392a017d13..8b84d9ab994 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanIntegerColumnTupleSource.java
index 98ccdf917f0..398d5aa689d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanIntegerColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanLongColumnTupleSource.java
index f36a535154b..ffcbd8b8d55 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanObjectColumnTupleSource.java
index 870fbe5ecd5..5bb94097491 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanReinterpretedBooleanColumnTupleSource.java
index c14f91d43e9..32380eb49ef 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanReinterpretedInstantColumnTupleSource.java
index a5773b5ca46..6ef23d682ce 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanShortColumnTupleSource.java
index 68778ca606e..4b0afc80bf3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantBooleanShortColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteBooleanColumnTupleSource.java
index dea6302364f..b51dbe98238 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteByteColumnTupleSource.java
index d6e37c9bdc3..d609a646323 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteCharacterColumnTupleSource.java
index 715abb0e91f..82cfeed4910 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteColumnTupleSource.java
index d28c80b284c..afcb299b331 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongByteTuple, Long, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteDoubleColumnTupleSource.java
index 6766a6ae309..18886d09ef1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteFloatColumnTupleSource.java
index a4d66c08fac..de5a01f8948 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteInstantColumnTupleSource.java
index 7001f0f5d2f..87c430126cb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteIntegerColumnTupleSource.java
index 8606ee0d0aa..573b8f02653 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteLongColumnTupleSource.java
index 4af7cc2a379..e4a81f07d88 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteObjectColumnTupleSource.java
index 399bf2a4454..b5f798fae0f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteReinterpretedBooleanColumnTupleSource.java
index 4bfae79bc06..60ffe2070f7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteReinterpretedInstantColumnTupleSource.java
index e136139cf8b..3c47bcbc96f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteShortColumnTupleSource.java
index d9704be5614..c264f5f85b8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantByteShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterBooleanColumnTupleSource.java
index 81bdc2ce84d..44d188f00b6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterByteColumnTupleSource.java
index 269987955c4..3ff28d75d95 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterCharacterColumnTupleSource.java
index d64aa4fc5a1..a7e571e9b0b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongCharCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongCharCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterColumnTupleSource.java
index a89649212e2..c1b682fd876 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongCharTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongCharTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongCharTuple, Long, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterDoubleColumnTupleSource.java
index 8036421eee7..5ec38ffc6f0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterFloatColumnTupleSource.java
index 625e21bc20e..55bd57481b8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterInstantColumnTupleSource.java
index c1d89e0127a..df2112689a9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterIntegerColumnTupleSource.java
index fb85e4e633a..c1b778160fd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterLongColumnTupleSource.java
index e594f6fa58c..00b629c2799 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterObjectColumnTupleSource.java
index cd6d78255bd..5f0c6803cd3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterReinterpretedBooleanColumnTupleSource.java
index 7e892687bd8..08b0b344d65 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongCharByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongCharByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterReinterpretedInstantColumnTupleSource.java
index da488561b77..fc1dd1a3d8d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongCharLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongCharLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterShortColumnTupleSource.java
index 88f08f59c09..96c3997cd67 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantCharacterShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongCharShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongCharShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongCharShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleBooleanColumnTupleSource.java
index ff11284b869..1952d6d44c9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleByteColumnTupleSource.java
index b0073a73e04..37147fa447d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleCharacterColumnTupleSource.java
index d2455b05339..b8fb82eb1c4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleColumnTupleSource.java
index 4981cfce5eb..9af88d75413 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongDoubleTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongDoubleTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongDoubleTuple, Long, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleDoubleColumnTupleSource.java
index 971a6171422..d14ac1dd71f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongDoubleDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleFloatColumnTupleSource.java
index b0373df7f34..fd1e504e672 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleInstantColumnTupleSource.java
index 4c9540517f5..57b6a0b1e81 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleIntegerColumnTupleSource.java
index 4e2b13d62dd..7ef21e85afe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleLongColumnTupleSource.java
index 6154212704b..c785b5d9d42 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleObjectColumnTupleSource.java
index d5c5954b4b2..6ec8f7fe719 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleReinterpretedBooleanColumnTupleSource.java
index 26dfebd21fa..36c824c0494 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleReinterpretedInstantColumnTupleSource.java
index 204fecc8142..b07bc123000 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleShortColumnTupleSource.java
index c7f9a97fcc5..7bea530af8a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantDoubleShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongDoubleShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongDoubleShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongDoubleShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatBooleanColumnTupleSource.java
index 31673957bd0..82f81204d4e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatByteColumnTupleSource.java
index 2b6de783d4b..84f99be2b4d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatCharacterColumnTupleSource.java
index 7b103a210c7..6311ea9304a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatColumnTupleSource.java
index 54f921005fa..a0f5efa2097 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongFloatTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongFloatTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongFloatTuple, Long, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatDoubleColumnTupleSource.java
index 7d46490c08a..3ac24b68fd9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatFloatColumnTupleSource.java
index 97dd48a1f31..a3951d6652f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongFloatFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatInstantColumnTupleSource.java
index c3a64244664..52fcf3de83c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatIntegerColumnTupleSource.java
index f17edd4d857..2e83b6b1003 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatLongColumnTupleSource.java
index 3b01223cef3..d179b18f096 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatObjectColumnTupleSource.java
index 96c0cb20856..334ea20e312 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatReinterpretedBooleanColumnTupleSource.java
index 1f4dd3e2654..2e024dd130f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongFloatByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongFloatByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatReinterpretedInstantColumnTupleSource.java
index 46a131f38ad..83428138f91 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongFloatLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongFloatLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatShortColumnTupleSource.java
index df7f9119e10..ed5485d0d43 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantFloatShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongFloatShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongFloatShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongFloatShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantBooleanColumnTupleSource.java
index 4d29a079f63..12fba4e7524 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantByteColumnTupleSource.java
index 1f0c41a3df9..94ec610295e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantCharacterColumnTupleSource.java
index 4ce9e5ca7fd..b648c673888 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantColumnTupleSource.java
index 12184f98e6a..fc71be41eb6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongLongTuple, Long, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantDoubleColumnTupleSource.java
index adde8eb97d3..46304e3e515 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantFloatColumnTupleSource.java
index 58fb57c02c5..1a8a6b55552 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantInstantColumnTupleSource.java
index a8c97d5da28..f1cf7efcc58 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantIntegerColumnTupleSource.java
index 7f8d7240941..1b0419502cd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantLongColumnTupleSource.java
index 7632dcfb286..f9a08678946 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantObjectColumnTupleSource.java
index 77b487e990b..e3d08bab3a2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantReinterpretedBooleanColumnTupleSource.java
index 8322162e69a..34c47507a63 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantReinterpretedInstantColumnTupleSource.java
index d0b3e9645ee..23cce20e6b7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantShortColumnTupleSource.java
index 7fd2299f1d2..92d1b263f04 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantInstantShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerBooleanColumnTupleSource.java
index 854b8ae1eb4..91f8f6c6fa5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerByteColumnTupleSource.java
index 734bab48a3a..8e4eeb59eff 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerCharacterColumnTupleSource.java
index 37c65cf2c1b..87c99eacfe5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntCharTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntCharTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerColumnTupleSource.java
index 82cb9e0f081..56f025063d3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongIntTuple createTupleFromReinterpretedValues(@NotNull final Obje
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongIntTuple tuple, int element
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongIntTuple, Long, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerDoubleColumnTupleSource.java
index ec6affb17ad..e3ec592d023 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntDoubleTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntDoubleTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerFloatColumnTupleSource.java
index b6faedfadbf..f19e0387e29 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntFloatTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntFloatTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerInstantColumnTupleSource.java
index 34b1e99edca..ef91cc75222 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerIntegerColumnTupleSource.java
index aec1016610c..f76ffd4091b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongIntIntTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongIntIntTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntIntTuple tu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerLongColumnTupleSource.java
index c696e110e42..3406b05c894 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerObjectColumnTupleSource.java
index 9c0c02534f5..93cfe6fe032 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntObjectTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntObjectTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntObjectTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerReinterpretedBooleanColumnTupleSource.java
index 33dac785d3c..17a91210907 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongIntByteTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntByteTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerReinterpretedInstantColumnTupleSource.java
index d6f026420e2..28d9620d587 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongIntLongTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntLongTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerShortColumnTupleSource.java
index 614c984042f..75e335eeb05 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantIntegerShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongIntShortTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongIntShortTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongIntShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongBooleanColumnTupleSource.java
index 7aab346d7e2..ab215a3751f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongByteColumnTupleSource.java
index 0d4f55293b0..b98bdad1cc4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongCharacterColumnTupleSource.java
index 8edcaee69a4..17f45c2a4d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongColumnTupleSource.java
index 4ecb2485e9d..857025957a6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongColumnTupleSource.java
@@ -77,6 +77,11 @@ public final LongLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final LongLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongLongTuple, Long, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongDoubleColumnTupleSource.java
index c499b67e974..5144d93dfe6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongFloatColumnTupleSource.java
index 6e03c7ef5ce..adb87f00715 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongInstantColumnTupleSource.java
index a143ba4dddf..e70a22bae08 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongIntegerColumnTupleSource.java
index 2a08936c2cd..10494dedd73 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongLongColumnTupleSource.java
index ca6f668d322..336d2155ad9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongObjectColumnTupleSource.java
index c669fd06f83..8202e3e69c0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongReinterpretedBooleanColumnTupleSource.java
index fb9df82b909..cb060f5a00f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongReinterpretedInstantColumnTupleSource.java
index e6f087099bf..fd95ca9cba3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongReinterpretedInstantColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongShortColumnTupleSource.java
index df9cb5f7d0f..e802f19813b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantLongShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectBooleanColumnTupleSource.java
index 393300d9151..eb459efc9cc 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectByteColumnTupleSource.java
index d0f7a2ddd8b..535e3fa2a9d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectCharacterColumnTupleSource.java
index 22f0405ff83..07a15b72b9a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongObjectCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongObjectCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectColumnTupleSource.java
index 9947c824273..a045b4c2a8a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongObjectTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongObjectTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongObjectTuple, Long, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectDoubleColumnTupleSource.java
index b3785e73088..393f0be722b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongObjectDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectFloatColumnTupleSource.java
index 4234e6f1dc9..f22a833122f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongObjectFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongObjectFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectInstantColumnTupleSource.java
index 99b3d7615ae..cabd7f858b9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectIntegerColumnTupleSource.java
index 25b41ae95fe..29767d130a3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongObjectIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongObjectIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectLongColumnTupleSource.java
index ec868c70e2c..d4388490833 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectObjectColumnTupleSource.java
index 4e6af10b401..333892682cb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectReinterpretedBooleanColumnTupleSource.java
index 5b4d254778c..c828bd20616 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongObjectByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectReinterpretedInstantColumnTupleSource.java
index 18868ecb179..800117dacb4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongObjectLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectShortColumnTupleSource.java
index ccdee2aeaef..ff86ef7535a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantObjectShortColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongObjectShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongObjectShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongObjectShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanBooleanColumnTupleSource.java
index a8274ad4348..c12a75e17f2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanByteColumnTupleSource.java
index 23ee58e4cc7..905035462d0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanCharacterColumnTupleSource.java
index c6d2fc97234..d17adccb798 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanCharacterColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index 51e1403835f..26c7c59f685 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -79,6 +79,11 @@ public final LongByteTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -104,6 +109,18 @@ public final Object exportElement(@NotNull final LongByteTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -125,6 +142,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongByteTuple, Long, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanDoubleColumnTupleSource.java
index 4f4fdf57370..34c84681e16 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanDoubleColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanFloatColumnTupleSource.java
index b8fde2d9658..1c264cfa13a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanFloatColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanInstantColumnTupleSource.java
index 6864ba23c46..41734dc3e08 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanIntegerColumnTupleSource.java
index 768056da248..a7a61a65668 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanIntegerColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanLongColumnTupleSource.java
index c934201ab16..58dc4bd66a0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanObjectColumnTupleSource.java
index e6a118377ff..9c2ab8926c3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanObjectColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index a39725ef0f3..c21497de631 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 20f808a78eb..81d6299bf09 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongByteLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongByteLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanShortColumnTupleSource.java
index bd3c3c53920..8af5872207b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedBooleanShortColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongByteShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongByteShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongByteShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantBooleanColumnTupleSource.java
index 88600d809b6..08a1b4906e0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantByteColumnTupleSource.java
index f3ed5928805..99ffae965c7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantCharacterColumnTupleSource.java
index ff1e50e7029..9225e3326f8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index 57e280cef2a..b3d7a107e3a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -77,6 +77,11 @@ public final LongLongTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final LongLongTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongLongTuple, Long, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantDoubleColumnTupleSource.java
index 372cf984492..d05b980da07 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantFloatColumnTupleSource.java
index 952c83a89ed..ffab1ab095e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantInstantColumnTupleSource.java
index 97d673bd7d3..1b3742fb446 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantIntegerColumnTupleSource.java
index 14d6577ffb8..81cbfdc8bac 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantLongColumnTupleSource.java
index c290972641d..109a2650e75 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantObjectColumnTupleSource.java
index b1d4f52f10f..7e63d4f951c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index c4d75ab18b0..a9f894e1443 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongLongByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongLongByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index 5911e3b05fd..1849e0f8f1d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -84,6 +84,11 @@ public final LongLongLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final LongLongLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantShortColumnTupleSource.java
index f1e07ac025f..baaaa980ca3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantReinterpretedInstantShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongLongShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongLongShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongLongShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortBooleanColumnTupleSource.java
index 8502f0a09ac..dc7029b8874 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortByteColumnTupleSource.java
index cc4785c85c1..586a0090649 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortCharacterColumnTupleSource.java
index b4ef2ad5c8a..e0328775d4d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortColumnTupleSource.java
index 9fa8664cf8b..a847d11e885 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortColumnTupleSource.java
@@ -78,6 +78,11 @@ public final LongShortTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final LongShortTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ReinterpretedInstantShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<LongShortTuple, Long, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortDoubleColumnTupleSource.java
index 3875607348c..baf439715de 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortFloatColumnTupleSource.java
index 4e8155004b6..1e8eaf52f0d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortInstantColumnTupleSource.java
index 3858cc28be5..8589c1a816d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortIntegerColumnTupleSource.java
index 5bfcd876e01..8a3133b8e80 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortLongColumnTupleSource.java
index 467f1cd3e19..1e22a36c844 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortObjectColumnTupleSource.java
index b2b47a240d3..95d3f406c96 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final LongShortObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final LongShortObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortReinterpretedBooleanColumnTupleSource.java
index 1a2eb1bb89e..919766cc90d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final LongShortByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final LongShortByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortReinterpretedInstantColumnTupleSource.java
index fd9f7b29345..b6b6a2357fe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongShortLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongShortLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortShortColumnTupleSource.java
index 720c9130fca..f4dfeda54fa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ReinterpretedInstantShortShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final LongShortShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final LongShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final LongShortShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple) {
+        dest[0] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = DateTimeUtils.epochNanosToInstant(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final LongShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final LongShortShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final LongShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanBooleanColumnTupleSource.java
index cc15f387df6..50d2462c08d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanByteColumnTupleSource.java
index 1beeb672604..70616ed30fb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanByteColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanCharacterColumnTupleSource.java
index 6fc227bb837..440dc5c85a8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanColumnTupleSource.java
index 58f142cf9d1..c6a4e14d003 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ShortByteTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ShortByteTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortByteTuple, Short, Boolean> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanDoubleColumnTupleSource.java
index 4fc00062c63..4534933c2f5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanFloatColumnTupleSource.java
index 8e39c8e4c4e..10a5a247a6a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanInstantColumnTupleSource.java
index 4b75a2be1f4..49eb45426a5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanIntegerColumnTupleSource.java
index 164168dd964..90442e0ca2d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanLongColumnTupleSource.java
index f8e68bd4b6c..e213716dc26 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanObjectColumnTupleSource.java
index a8542b5026c..f6c226c365a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanReinterpretedBooleanColumnTupleSource.java
index d777f59cd24..44a792f606f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanReinterpretedInstantColumnTupleSource.java
index 413eebffab4..64dca578c54 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ShortByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ShortByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanShortColumnTupleSource.java
index 2f63ddba958..828bf52be18 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortBooleanShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteBooleanColumnTupleSource.java
index 13600821998..39a98cde119 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteByteColumnTupleSource.java
index ef1d38ae2d9..ec69a6b25e9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteCharacterColumnTupleSource.java
index fa8841fa3ad..986c36b7657 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteColumnTupleSource.java
index fcd4747ae8b..d31510c1312 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ShortByteTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ShortByteTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortByteColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortByteTuple, Short, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteDoubleColumnTupleSource.java
index c0ab29bbaf3..cdecc91557d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteFloatColumnTupleSource.java
index 15a0e5ccf6d..88ad4c7ad32 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteInstantColumnTupleSource.java
index 2776ee1516f..250e95fea82 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteIntegerColumnTupleSource.java
index 03cfa66d750..8da2b03318b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteLongColumnTupleSource.java
index 58c74e43004..939571394da 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteObjectColumnTupleSource.java
index 9df4f40066b..5a0ea71885e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteReinterpretedBooleanColumnTupleSource.java
index fd52d422db6..bdb21b24080 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteReinterpretedInstantColumnTupleSource.java
index 9e416062595..ffaaa579a58 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteShortColumnTupleSource.java
index a8f9d140bcd..2f45cef234d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortByteShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortByteShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterBooleanColumnTupleSource.java
index ea1a39f61e9..70d8208ed51 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortCharByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortCharByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterByteColumnTupleSource.java
index 8bd2c2d69e6..13ec3961769 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortCharByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortCharByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterCharacterColumnTupleSource.java
index c6412c3436b..ba50d09be5c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortCharCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortCharCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterColumnTupleSource.java
index a09980f6edd..4fd1da97216 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ShortCharTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ShortCharTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortCharacterColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortCharTuple, Short, Character> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterDoubleColumnTupleSource.java
index 0803dc87881..e25e9cb335a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortCharDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortCharDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterFloatColumnTupleSource.java
index 4919c8fcc7c..9b260b667f2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortCharFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortCharFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterInstantColumnTupleSource.java
index 0d1392db13a..d67f8633e8d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortCharLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortCharLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterIntegerColumnTupleSource.java
index e909522547d..67512e74168 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortCharIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortCharIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterLongColumnTupleSource.java
index dbbb0daf6be..6120307c339 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortCharLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortCharLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterObjectColumnTupleSource.java
index 797763ba653..aac74d6a476 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortCharObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortCharObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterReinterpretedBooleanColumnTupleSource.java
index 0d59cecaf55..366d8ae1089 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortCharByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortCharByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterReinterpretedInstantColumnTupleSource.java
index 5ceef169746..58a42f900f5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortCharLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortCharLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterShortColumnTupleSource.java
index 6744b842a3b..c2912c0cb74 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortCharacterShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortCharShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortCharShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortCharShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortCharShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortCharShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortCharShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleBooleanColumnTupleSource.java
index 2f19a3fc8c5..7c958b6a475 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleByteColumnTupleSource.java
index 3ae25b2a4e7..b6beb682663 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleCharacterColumnTupleSource.java
index a70d54a3232..39ba3dafc70 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortDoubleCharTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortDoubleCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleCharTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleColumnTupleSource.java
index cfcd71fb094..f8afb977218 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ShortDoubleTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ShortDoubleTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortDoubleColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortDoubleTuple, Short, Double> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleDoubleColumnTupleSource.java
index ec79fadc453..a5a9845aee5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortDoubleDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortDoubleDoubleTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleDoubleT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleFloatColumnTupleSource.java
index c8ead55e478..04cbf3eedd9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortDoubleFloatTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortDoubleFloatTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleFloatTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleInstantColumnTupleSource.java
index 607b07724c0..a39c6b22e25 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleIntegerColumnTupleSource.java
index eec76f29a98..a921c46da09 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortDoubleIntTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortDoubleIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleIntTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleLongColumnTupleSource.java
index bfa41f60135..88684d5ac2d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleObjectColumnTupleSource.java
index 61c87cff607..11395960114 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortDoubleObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortDoubleObjectTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleObjectT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleReinterpretedBooleanColumnTupleSource.java
index fc534cdf33f..18257fb9900 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortDoubleByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortDoubleByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleReinterpretedInstantColumnTupleSource.java
index 0bc8d53bdea..61a356bbc74 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortDoubleLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortDoubleLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleShortColumnTupleSource.java
index 80547ff0b03..ed5cfaa577e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortDoubleShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortDoubleShortTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortDoubleShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortDoubleShortTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortDoubleShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortDoubleShortTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortDoubleShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatBooleanColumnTupleSource.java
index a476a7a9c08..c32cbcd4776 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortFloatByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatByteColumnTupleSource.java
index 0a3cec82b77..f02b00258fa 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortFloatByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatCharacterColumnTupleSource.java
index ef9c08c5a63..135bbe2b679 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortFloatCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortFloatCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatColumnTupleSource.java
index 8e8de63e98c..685be065f5f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ShortFloatTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ShortFloatTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortFloatColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortFloatTuple, Short, Float> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatDoubleColumnTupleSource.java
index 1840b0e05fe..b3d2904a371 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortFloatDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortFloatDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatFloatColumnTupleSource.java
index 19854df6d14..5caa58c5bd8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortFloatFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortFloatFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatInstantColumnTupleSource.java
index 1bd938812a9..16ccca1d2ad 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortFloatLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatIntegerColumnTupleSource.java
index 9b239978462..de5db96062a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortFloatIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortFloatIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatLongColumnTupleSource.java
index eeccaefe3a2..d9b8ef5df89 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortFloatLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatObjectColumnTupleSource.java
index 3e35b702028..fdb4b624b70 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortFloatObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortFloatObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatReinterpretedBooleanColumnTupleSource.java
index b9f8eaffe7a..ab4627ebcd5 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortFloatByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortFloatByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatReinterpretedInstantColumnTupleSource.java
index 7104bf21d25..8fd80d3e733 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortFloatLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortFloatLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatShortColumnTupleSource.java
index a51804b924e..d158102064b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortFloatShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortFloatShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortFloatShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortFloatShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortFloatShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortFloatShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortFloatShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantBooleanColumnTupleSource.java
index 7a245c93711..88658957b1d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantBooleanColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantByteColumnTupleSource.java
index 61a70c44e39..1013dc60dd4 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantCharacterColumnTupleSource.java
index f8ad6de1fbe..c7696304619 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantColumnTupleSource.java
index 77ad921b7eb..4f0e9b83d0d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final ShortLongTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final ShortLongTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortLongTuple, Short, Instant> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantDoubleColumnTupleSource.java
index 2229caa7c45..0fb96dfd4d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantFloatColumnTupleSource.java
index 5f725354b9b..62817640af2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantInstantColumnTupleSource.java
index 508fa20fa97..3d4e6768b23 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantIntegerColumnTupleSource.java
index 76de1a777c7..ca7f08c637e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantLongColumnTupleSource.java
index 3e52535e122..725f43179cb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantLongColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantObjectColumnTupleSource.java
index d3e3f0fac08..8dcfd8eb332 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortLongObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantReinterpretedBooleanColumnTupleSource.java
index c8e0e05fc4b..86565009111 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ShortLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ShortLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantReinterpretedInstantColumnTupleSource.java
index be460e7f87f..1c4e9495a4c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantShortColumnTupleSource.java
index 02c78815eec..181811a0359 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortInstantShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortLongShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerBooleanColumnTupleSource.java
index 86f1aecb2d0..fc938452362 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortIntByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerByteColumnTupleSource.java
index e8d3d39e4b9..a7081ddef08 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortIntByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerCharacterColumnTupleSource.java
index f7f4084dfff..fdd0cf2ae90 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortIntCharTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortIntCharTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerColumnTupleSource.java
index 8c9e0fff074..1f55e1a059d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ShortIntTuple createTupleFromReinterpretedValues(@NotNull final Obj
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ShortIntTuple tuple, int elemen
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortIntegerColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortIntTuple, Short, Integer> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerDoubleColumnTupleSource.java
index 4ddbbb35e16..5287eb11eb3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortIntDoubleTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortIntDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntDoubleTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerFloatColumnTupleSource.java
index d76574c5bde..9778dc0e7db 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortIntFloatTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortIntFloatTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntFloatTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerInstantColumnTupleSource.java
index 93a552ce9d1..efa54673ee2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortIntLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerIntegerColumnTupleSource.java
index 1625f81fb83..5c7efd04947 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortIntIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortIntIntTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntIntTuple t
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerLongColumnTupleSource.java
index 93f5075da4b..039930710ca 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortIntLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerObjectColumnTupleSource.java
index d4c07907338..0bddaa48a9b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortIntObjectTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortIntObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntObjectTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerReinterpretedBooleanColumnTupleSource.java
index 48cc913597f..51b348b1933 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortIntByteTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortIntByteTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerReinterpretedInstantColumnTupleSource.java
index 1dfa61b30df..0a6806485e6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortIntLongTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortIntLongTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerShortColumnTupleSource.java
index 4f38e692626..7183c18f0da 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortIntegerShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortIntShortTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortIntShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortIntShortTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortIntShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortIntShortTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortIntShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongBooleanColumnTupleSource.java
index 75b29a9121a..d9de86ceeea 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongByteColumnTupleSource.java
index 37a85a949b3..70d37bf31fe 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongCharacterColumnTupleSource.java
index f0efea95800..ca4ed7b5c14 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortLongCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortLongCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongColumnTupleSource.java
index bb4379bf43d..397cd876360 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ShortLongTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ShortLongTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortLongColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortLongTuple, Short, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongDoubleColumnTupleSource.java
index df32876629e..2de957d4433 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongFloatColumnTupleSource.java
index 65909af7d59..542d93b2c78 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortLongFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongInstantColumnTupleSource.java
index 947b7d09716..d847f2bc24d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongIntegerColumnTupleSource.java
index a9b133b3194..988de167a23 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortLongIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongLongColumnTupleSource.java
index e3cb98c8307..9e3f5915d26 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongObjectColumnTupleSource.java
index 53e69fc5189..a64f03b559f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongObjectColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortLongObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongReinterpretedBooleanColumnTupleSource.java
index af6e974de63..9718683f21b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongReinterpretedInstantColumnTupleSource.java
index 44e3798fefd..685ff88ddd6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongShortColumnTupleSource.java
index 3c4bb6adfbe..d6c558a8ecd 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortLongShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortLongShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectBooleanColumnTupleSource.java
index ab77bf274db..de6f2d2694e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortObjectByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectByteColumnTupleSource.java
index 22553326636..d05154e3905 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortObjectByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectCharacterColumnTupleSource.java
index a8d376abe8b..636f72db0d9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectCharacterColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortObjectCharTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortObjectCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectCharTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectColumnTupleSource.java
index c2998c80675..8a216f7788e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectColumnTupleSource.java
@@ -76,6 +76,11 @@ public final ShortObjectTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -101,6 +106,18 @@ public final Object exportElement(@NotNull final ShortObjectTuple tuple, int ele
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -122,6 +139,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortObjectColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortObjectTuple, Short, Object> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectDoubleColumnTupleSource.java
index b9ced724037..0adf84ad822 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectDoubleColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortObjectDoubleTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortObjectDoubleTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectDoubleT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectFloatColumnTupleSource.java
index ef34fa2f5c7..2bb1bb7c993 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectFloatColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortObjectFloatTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortObjectFloatTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectFloatTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectInstantColumnTupleSource.java
index 3b697d5bad9..929660f09cb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortObjectLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectIntegerColumnTupleSource.java
index fe3696f2006..5faa6b9f8eb 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectIntegerColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortObjectIntTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortObjectIntTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectIntTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectLongColumnTupleSource.java
index 5dbee439ec0..36cf3352006 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectLongColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortObjectLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectObjectColumnTupleSource.java
index 8ed9b7fbd26..344a266211f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortObjectObjectTuple createTupleFromReinterpretedValues(@NotNull
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortObjectObjectTuple tuple, i
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectObjectT
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectReinterpretedBooleanColumnTupleSource.java
index a300e229c29..ca680ee32a1 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectReinterpretedBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortObjectByteTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortObjectByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectByteTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectReinterpretedInstantColumnTupleSource.java
index ea1e395fbc2..b6114b832c2 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectReinterpretedInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortObjectLongTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortObjectLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectLongTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectShortColumnTupleSource.java
index 26e70f367d8..28e43050479 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortObjectShortColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortObjectShortTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortObjectShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortObjectShortTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortObjectShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortObjectShortTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = tuple.getSecondElement();
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortObjectShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = tuple.getSecondElement();
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanBooleanColumnTupleSource.java
index a1228463b40..b307849c2b0 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanBooleanColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanByteColumnTupleSource.java
index c88d588e970..53b858bb6c3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanByteColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanCharacterColumnTupleSource.java
index b766b92c7ff..330493726a8 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanCharacterColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanColumnTupleSource.java
index ada66272bbb..8ae647c412d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanColumnTupleSource.java
@@ -77,6 +77,11 @@ public final ShortByteTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -102,6 +107,18 @@ public final Object exportElement(@NotNull final ShortByteTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -123,6 +140,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortReinterpretedBooleanColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortByteTuple, Short, Byte> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanDoubleColumnTupleSource.java
index a25ab251202..f0e257056d7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanDoubleColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanFloatColumnTupleSource.java
index 614329ffaef..a7df0c2336b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanFloatColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanInstantColumnTupleSource.java
index e0d8b053d7f..9c33cf3d95a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ShortByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ShortByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanIntegerColumnTupleSource.java
index b68e9da3bf0..19f223d13bf 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanIntegerColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanLongColumnTupleSource.java
index 446345a7109..8e7ef55fe58 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanObjectColumnTupleSource.java
index 0b2545d6333..db9664bc451 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanObjectColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortByteObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortByteObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
index 8fddd35e892..65611116835 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
index 5a671627d43..e76db3c853f 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanReinterpretedInstantColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ShortByteLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ShortByteLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanShortColumnTupleSource.java
index 99230ccccfa..70254b503c7 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedBooleanShortColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortByteShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortByteShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortByteShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = BooleanUtils.byteAsBoolean(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortByteShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortByteShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortByteShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantBooleanColumnTupleSource.java
index e8054258e64..758dc0e575a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ShortLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ShortLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantByteColumnTupleSource.java
index 74b12331502..4f163bc94e6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantByteColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantCharacterColumnTupleSource.java
index 29f85a14df6..3e94fe5040a 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantCharacterColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongCharTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongCharTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongCharTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantColumnTupleSource.java
index b5b17588b8d..1cbd9496222 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantColumnTupleSource.java
@@ -78,6 +78,11 @@ public final ShortLongTuple createTupleFromReinterpretedValues(@NotNull final Ob
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -103,6 +108,18 @@ public final Object exportElement(@NotNull final ShortLongTuple tuple, int eleme
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -124,6 +141,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortReinterpretedInstantColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortLongTuple, Short, Long> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantDoubleColumnTupleSource.java
index 9ff388ed092..00e8b8f6638 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantDoubleColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongDoubleTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongDoubleTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongDoubleTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantFloatColumnTupleSource.java
index ca8a499d5e9..bad36f6ccda 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantFloatColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongFloatTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongFloatTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantInstantColumnTupleSource.java
index 9d73886fd75..df0e27f313b 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantInstantColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantIntegerColumnTupleSource.java
index 2f40103e272..ea734084e97 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantIntegerColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongIntTuple createTupleFromReinterpretedValues(@NotNull final
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongIntTuple tuple, int el
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantLongColumnTupleSource.java
index d5080783a8b..9fce6e64442 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantLongColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantObjectColumnTupleSource.java
index 431a75890c2..ae222edb202 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantObjectColumnTupleSource.java
@@ -86,6 +86,11 @@ public final ShortLongObjectTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -118,6 +123,20 @@ public final Object exportElement(@NotNull final ShortLongObjectTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -131,6 +150,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongObjectTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
index b54cab65913..2110a6fd10c 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantReinterpretedBooleanColumnTupleSource.java
@@ -87,6 +87,11 @@ public final ShortLongByteTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -119,6 +124,20 @@ public final Object exportElement(@NotNull final ShortLongByteTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -132,6 +151,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongByteTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantReinterpretedInstantColumnTupleSource.java
index f3766068220..86e46123521 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortLongLongTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortLongLongTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongLongTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantShortColumnTupleSource.java
index 64ab8ad14c5..bdf0a1c24d6 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortReinterpretedInstantShortColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortLongShortTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortLongShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortLongShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = DateTimeUtils.epochNanosToInstant(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortLongShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortLongShortTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortLongShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortBooleanColumnTupleSource.java
index f8efeb97bc5..81750047fab 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortShortByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortByteColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortByteColumnTupleSource.java
index 5962d04683d..82ee3fa2b2d 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortByteColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortByteColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortShortByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortCharacterColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortCharacterColumnTupleSource.java
index cfb8aa4f3c6..23c5275d66e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortCharacterColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortCharacterColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortShortCharTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortCharTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortShortCharTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortCharTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortCharTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortCharTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortCharTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortColumnTupleSource.java
index 3b98b880317..2b0bb1c5e93 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortColumnTupleSource.java
@@ -75,6 +75,11 @@ public final ShortShortTuple createTupleFromReinterpretedValues(@NotNull final O
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 2;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -100,6 +105,18 @@ public final Object exportElement(@NotNull final ShortShortTuple tuple, int elem
         throw new IllegalArgumentException("Bad elementIndex for 2 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -121,6 +138,18 @@ protected void convertChunks(@NotNull WritableChunk<? super Values> destination,
         destination.setSize(chunkSize);
     }
 
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+    }
+
     /** {@link TwoColumnTupleSourceFactory} for instances of {@link ShortShortColumnTupleSource}. **/
     private static final class Factory implements TwoColumnTupleSourceFactory<ShortShortTuple, Short, Short> {
 
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortDoubleColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortDoubleColumnTupleSource.java
index ce63555843e..a5ab8ed0ec3 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortDoubleColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortDoubleColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortShortDoubleTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortDoubleTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortShortDoubleTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortDoubleTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortDoubleTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortDoubleTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortDoubleTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortFloatColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortFloatColumnTupleSource.java
index 22acb5dcabc..c4bfc174f50 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortFloatColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortFloatColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortShortFloatTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortFloatTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortShortFloatTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortFloatTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortFloatTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortFloatTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortFloatTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortInstantColumnTupleSource.java
index 3be3991dc43..cfe55587112 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortShortLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortIntegerColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortIntegerColumnTupleSource.java
index e49e8df5535..72c2633007e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortIntegerColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortIntegerColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortShortIntTuple createTupleFromReinterpretedValues(@NotNull fina
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortIntTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortShortIntTuple tuple, int e
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortIntTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortIntTuple
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortIntTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortIntTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortLongColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortLongColumnTupleSource.java
index b71922ccac8..7c8d47db2af 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortLongColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortLongColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortShortLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortObjectColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortObjectColumnTupleSource.java
index 51f8c883317..efd7740dc1e 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortObjectColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortObjectColumnTupleSource.java
@@ -83,6 +83,11 @@ public final ShortShortObjectTuple createTupleFromReinterpretedValues(@NotNull f
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortObjectTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -115,6 +120,20 @@ public final Object exportElement(@NotNull final ShortShortObjectTuple tuple, in
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortObjectTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -128,6 +147,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortObjectTu
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortObjectTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = tuple.getThirdElement();
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortObjectTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = tuple.getThirdElement();
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortReinterpretedBooleanColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortReinterpretedBooleanColumnTupleSource.java
index 3dabf728bc1..ade9c896ab9 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortReinterpretedBooleanColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortReinterpretedBooleanColumnTupleSource.java
@@ -84,6 +84,11 @@ public final ShortShortByteTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortByteTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -116,6 +121,20 @@ public final Object exportElement(@NotNull final ShortShortByteTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = BooleanUtils.byteAsBoolean(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortByteTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -129,6 +148,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortByteTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortByteTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortReinterpretedInstantColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortReinterpretedInstantColumnTupleSource.java
index ac280ab957e..021695e5154 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortReinterpretedInstantColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortReinterpretedInstantColumnTupleSource.java
@@ -85,6 +85,11 @@ public final ShortShortLongTuple createTupleFromReinterpretedValues(@NotNull fin
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortLongTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -117,6 +122,20 @@ public final Object exportElement(@NotNull final ShortShortLongTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = DateTimeUtils.epochNanosToInstant(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortLongTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -130,6 +149,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortLongTupl
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortLongTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortShortColumnTupleSource.java b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortShortColumnTupleSource.java
index 3bd193a97f3..24e0ca9fe97 100644
--- a/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortShortColumnTupleSource.java
+++ b/engine/tuplesource/src/main/java/io/deephaven/engine/table/impl/tuplesource/generated/ShortShortShortColumnTupleSource.java
@@ -82,6 +82,11 @@ public final ShortShortShortTuple createTupleFromReinterpretedValues(@NotNull fi
         );
     }
 
+    @Override
+    public final int tupleLength() {
+        return 3;
+    }
+
     @SuppressWarnings("unchecked")
     @Override
     public final <ELEMENT_TYPE> void exportElement(@NotNull final ShortShortShortTuple tuple, final int elementIndex, @NotNull final WritableColumnSource<ELEMENT_TYPE> writableSource, final long destinationRowKey) {
@@ -114,6 +119,20 @@ public final Object exportElement(@NotNull final ShortShortShortTuple tuple, int
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
 
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ShortShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
     @Override
     public final Object exportElementReinterpreted(@NotNull final ShortShortShortTuple tuple, int elementIndex) {
         if (elementIndex == 0) {
@@ -127,6 +146,20 @@ public final Object exportElementReinterpreted(@NotNull final ShortShortShortTup
         }
         throw new IllegalArgumentException("Bad elementIndex for 3 element tuple: " + elementIndex);
     }
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortShortTuple tuple) {
+        dest[0] = TypeUtils.box(tuple.getFirstElement());
+        dest[1] = TypeUtils.box(tuple.getSecondElement());
+        dest[2] = TypeUtils.box(tuple.getThirdElement());
+    }
+
+    @Override
+    public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ShortShortShortTuple tuple, final int @NotNull [] map) {
+        dest[map[0]] = TypeUtils.box(tuple.getFirstElement());
+        dest[map[1]] = TypeUtils.box(tuple.getSecondElement());
+        dest[map[2]] = TypeUtils.box(tuple.getThirdElement());
+    }
+
 
     @Override
     protected void convertChunks(@NotNull WritableChunk<? super Values> destination, int chunkSize, Chunk<? extends Values> [] chunks) {
diff --git a/replication/static/src/main/java/io/deephaven/replicators/TupleSourceCodeGenerator.java b/replication/static/src/main/java/io/deephaven/replicators/TupleSourceCodeGenerator.java
index 5eb2f17e54c..edb647b2894 100644
--- a/replication/static/src/main/java/io/deephaven/replicators/TupleSourceCodeGenerator.java
+++ b/replication/static/src/main/java/io/deephaven/replicators/TupleSourceCodeGenerator.java
@@ -369,6 +369,15 @@ private String generateTwoColumnTupleSource(@NotNull final String className, @No
 
         code.append(NEW_LINE);
 
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter).append("public final int tupleLength() {").append(NEW_LINE);
+        indenter.increaseLevel();
+        code.append(indenter).append("return 2;").append(NEW_LINE);
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
         code.append(indenter).append("@SuppressWarnings(\"unchecked\")").append(NEW_LINE);
         code.append(indenter).append("@Override").append(NEW_LINE);
         code.append(indenter).append("public final <ELEMENT_TYPE> void exportElement(@NotNull final ")
@@ -418,6 +427,34 @@ private String generateTwoColumnTupleSource(@NotNull final String className, @No
 
         code.append(NEW_LINE);
 
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter).append("public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ")
+                .append(tupleClassName)
+                .append(" tuple) {").append(NEW_LINE);
+        indenter.increaseLevel();
+        code.append(indenter).append("dest[0] = ").append(type1.getBoxingText("tuple.getFirstElement()")).append(";")
+                .append(NEW_LINE);
+        code.append(indenter).append("dest[1] = ").append(type2.getBoxingText("tuple.getSecondElement()")).append(";")
+                .append(NEW_LINE);
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter).append("public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ")
+                .append(tupleClassName)
+                .append(" tuple, final int @NotNull [] map) {").append(NEW_LINE);
+        indenter.increaseLevel();
+        code.append(indenter).append("dest[map[0]] = ").append(type1.getBoxingText("tuple.getFirstElement()"))
+                .append(";").append(NEW_LINE);
+        code.append(indenter).append("dest[map[1]] = ").append(type2.getBoxingText("tuple.getSecondElement()"))
+                .append(";").append(NEW_LINE);
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
         code.append(indenter).append("@Override").append(NEW_LINE);
         code.append(indenter).append("public final Object exportElementReinterpreted(@NotNull final ")
                 .append(tupleClassName).append(" tuple, int elementIndex) {").append(NEW_LINE);
@@ -454,6 +491,64 @@ private String generateTwoColumnTupleSource(@NotNull final String className, @No
         code.append(indenter.decreaseLevel()).append("}").append(NEW_LINE);
         code.append(NEW_LINE);
 
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter)
+                .append("public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ")
+                .append(tupleClassName)
+                .append(" tuple) {").append(NEW_LINE);
+        indenter.increaseLevel();
+        if (type1.isReinterpreted()) {
+            code.append(indenter).append("dest[0] = ")
+                    .append(forPrimitive(type1.elementClassName).getBoxingText("tuple.getFirstElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[0] = ").append(type1.getBoxingText("tuple.getFirstElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        if (type2.isReinterpreted()) {
+            code.append(indenter).append("dest[1] = ")
+                    .append(forPrimitive(type2.elementClassName).getBoxingText("tuple.getSecondElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[1] = ").append(type2.getBoxingText("tuple.getSecondElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter)
+                .append("public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ")
+                .append(tupleClassName)
+                .append(" tuple, final int @NotNull [] map) {").append(NEW_LINE);
+        indenter.increaseLevel();
+        if (type1.isReinterpreted()) {
+            code.append(indenter).append("dest[map[0]] = ")
+                    .append(forPrimitive(type1.elementClassName).getBoxingText("tuple.getFirstElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[map[0]] = ").append(type1.getBoxingText("tuple.getFirstElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        if (type2.isReinterpreted()) {
+            code.append(indenter).append("dest[map[1]] = ")
+                    .append(forPrimitive(type2.elementClassName).getBoxingText("tuple.getSecondElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[map[1]] = ").append(type2.getBoxingText("tuple.getSecondElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
         code.append(indenter).append("/** {@link ").append(TWO_COLUMN_FACTORY_SIMPLE_NAME)
                 .append("} for instances of {@link ").append(className).append("}. **/").append(NEW_LINE);
         code.append(indenter).append("private static final class Factory implements ")
@@ -648,6 +743,15 @@ private String generateThreeColumnTupleSource(@NotNull final String className,
 
         code.append(NEW_LINE);
 
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter).append("public final int tupleLength() {").append(NEW_LINE);
+        indenter.increaseLevel();
+        code.append(indenter).append("return 3;").append(NEW_LINE);
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
         code.append(indenter).append("@SuppressWarnings(\"unchecked\")").append(NEW_LINE);
         code.append(indenter).append("@Override").append(NEW_LINE);
         code.append(indenter).append("public final <ELEMENT_TYPE> void exportElement(@NotNull final ")
@@ -708,6 +812,38 @@ private String generateThreeColumnTupleSource(@NotNull final String className,
 
         code.append(NEW_LINE);
 
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter).append("public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ")
+                .append(tupleClassName)
+                .append(" tuple) {").append(NEW_LINE);
+        indenter.increaseLevel();
+        code.append(indenter).append("dest[0] = ").append(type1.getBoxingText("tuple.getFirstElement()")).append(";")
+                .append(NEW_LINE);
+        code.append(indenter).append("dest[1] = ").append(type2.getBoxingText("tuple.getSecondElement()")).append(";")
+                .append(NEW_LINE);
+        code.append(indenter).append("dest[2] = ").append(type3.getBoxingText("tuple.getThirdElement()")).append(";")
+                .append(NEW_LINE);
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter).append("public final void exportAllTo(final Object @NotNull [] dest, @NotNull final ")
+                .append(tupleClassName)
+                .append(" tuple, final int @NotNull [] map) {").append(NEW_LINE);
+        indenter.increaseLevel();
+        code.append(indenter).append("dest[map[0]] = ").append(type1.getBoxingText("tuple.getFirstElement()"))
+                .append(";").append(NEW_LINE);
+        code.append(indenter).append("dest[map[1]] = ").append(type2.getBoxingText("tuple.getSecondElement()"))
+                .append(";").append(NEW_LINE);
+        code.append(indenter).append("dest[map[2]] = ").append(type3.getBoxingText("tuple.getThirdElement()"))
+                .append(";").append(NEW_LINE);
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
         code.append(indenter).append("@Override").append(NEW_LINE);
         code.append(indenter).append("public final Object exportElementReinterpreted(@NotNull final ")
                 .append(tupleClassName).append(" tuple, int elementIndex) {").append(NEW_LINE);
@@ -727,6 +863,82 @@ private String generateThreeColumnTupleSource(@NotNull final String className,
         indenter.decreaseLevel();
         code.append(indenter).append('}').append(NEW_LINE);
 
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter)
+                .append("public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ")
+                .append(tupleClassName)
+                .append(" tuple) {").append(NEW_LINE);
+        indenter.increaseLevel();
+        if (type1.isReinterpreted()) {
+            code.append(indenter).append("dest[0] = ")
+                    .append(forPrimitive(type1.elementClassName).getBoxingText("tuple.getFirstElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[0] = ").append(type1.getBoxingText("tuple.getFirstElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        if (type2.isReinterpreted()) {
+            code.append(indenter).append("dest[1] = ")
+                    .append(forPrimitive(type2.elementClassName).getBoxingText("tuple.getSecondElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[1] = ").append(type2.getBoxingText("tuple.getSecondElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        if (type3.isReinterpreted()) {
+            code.append(indenter).append("dest[2] = ")
+                    .append(forPrimitive(type3.elementClassName).getBoxingText("tuple.getThirdElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[2] = ").append(type3.getBoxingText("tuple.getThirdElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
+        code.append(indenter).append("@Override").append(NEW_LINE);
+        code.append(indenter)
+                .append("public final void exportAllReinterpretedTo(final Object @NotNull [] dest, @NotNull final ")
+                .append(tupleClassName)
+                .append(" tuple, final int @NotNull [] map) {").append(NEW_LINE);
+        indenter.increaseLevel();
+        if (type1.isReinterpreted()) {
+            code.append(indenter).append("dest[map[0]] = ")
+                    .append(forPrimitive(type1.elementClassName).getBoxingText("tuple.getFirstElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[map[0]] = ").append(type1.getBoxingText("tuple.getFirstElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        if (type2.isReinterpreted()) {
+            code.append(indenter).append("dest[map[1]] = ")
+                    .append(forPrimitive(type2.elementClassName).getBoxingText("tuple.getSecondElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[map[1]] = ").append(type2.getBoxingText("tuple.getSecondElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        if (type3.isReinterpreted()) {
+            code.append(indenter).append("dest[map[2]] = ")
+                    .append(forPrimitive(type3.elementClassName).getBoxingText("tuple.getThirdElement()")).append(";")
+                    .append(NEW_LINE);
+        } else {
+            code.append(indenter).append("dest[map[2]] = ").append(type3.getBoxingText("tuple.getThirdElement()"))
+                    .append(";")
+                    .append(NEW_LINE);
+        }
+        indenter.decreaseLevel();
+        code.append(indenter).append('}').append(NEW_LINE);
+
+        code.append(NEW_LINE);
+
         code.append(NEW_LINE);
 
         code.append(indenter).append("@Override").append((NEW_LINE));