@loaders.gl/parquet 5.0.0-alpha.2 → 5.0.0-alpha.4

package/src/parquetjs/codecs/delta.ts

@@ -7,6 +7,7 @@ import type {PrimitiveType} from '../schema/declare';
 import {concatUint8Arrays, copyUint8Array, toUint8Array} from '../utils/binary-utils';
 import {
   getParquetValueOutput,
+  reserveParquetByteArrayOutput,
   type CursorBuffer,
   type ParquetCodecOptions,
   type ParquetValueBuffer
@@ -15,6 +16,8 @@ import {
 const DELTA_BLOCK_SIZE = 128;
 const DELTA_MINI_BLOCK_COUNT = 4;
 const DELTA_VALUES_PER_MINI_BLOCK = DELTA_BLOCK_SIZE / DELTA_MINI_BLOCK_COUNT;
+const UINT32_BASE = 0x1_0000_0000;
+const IS_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
 
 /** Encodes INT32 or INT64 values using Parquet DELTA_BINARY_PACKED. */
 export function encodeDeltaBinaryPackedValues(
@@ -264,6 +267,31 @@ function decodeDeltaBinaryPackedInt32Values(
   while (outputIndex < count) {
     const minimumDelta = readZigZagVarInt32(cursor);
     const bitWidths = readBitWidths(cursor, miniBlockCount, 32);
+    const activeMiniBlockCount = Math.min(
+      miniBlockCount,
+      Math.ceil((count - outputIndex) / valuesPerMiniBlock)
+    );
+    // Writers commonly select one width for every mini-block in a block. Fuse that contiguous
+    // bitstream so the decoder pays call/state setup once instead of once per 32 values.
+    if (haveEqualBitWidths(bitWidths, activeMiniBlockCount)) {
+      const bitWidth = bitWidths[0];
+      const valueCount = Math.min(valuesPerMiniBlock * activeMiniBlockCount, count - outputIndex);
+      const packedByteLength = (valuesPerMiniBlock * activeMiniBlockCount * bitWidth) / 8;
+      assertReadable(cursor, packedByteLength);
+      value = decodeInt32MiniBlock(
+        cursor.buffer,
+        cursor.offset,
+        bitWidth,
+        valueCount,
+        minimumDelta,
+        value,
+        output,
+        outputOffset + outputIndex
+      );
+      outputIndex += valueCount;
+      cursor.offset += packedByteLength;
+      continue;
+    }
     for (const bitWidth of bitWidths) {
       const packedOffset = cursor.offset;
       const packedByteLength = (valuesPerMiniBlock * bitWidth) / 8;
@@ -310,6 +338,26 @@ function decodeInt32MiniBlock(
     return value;
   }
 
+  if (bitWidth <= 24) {
+    // Bitwise reservoirs stay exact through 24 bits and are substantially cheaper than the
+    // division-based reservoir required for wider INT32 deltas.
+    const mask = 2 ** bitWidth - 1;
+    let packedBits = 0;
+    let packedBitCount = 0;
+    let byteOffset = packedOffset;
+    for (let index = 0; index < count; index++) {
+      while (packedBitCount < bitWidth) {
+        packedBits |= buffer[byteOffset++] << packedBitCount;
+        packedBitCount += 8;
+      }
+      value = (value + minimumDelta + (packedBits & mask)) | 0;
+      output[outputOffset + index] = value;
+      packedBits >>>= bitWidth;
+      packedBitCount -= bitWidth;
+    }
+    return value;
+  }
+
   const divisor = 2 ** bitWidth;
   let packedBits = 0;
   let packedBitCount = 0;
@@ -337,6 +385,21 @@ function decodeDeltaBinaryPackedInt64Values(
   options: ParquetCodecOptions
 ): ParquetValueBuffer {
   const {output, outputOffset} = getParquetValueOutput(options, count);
+  if (options.int64AsBigInt && output instanceof BigInt64Array) {
+    // BigInt arithmetic per value is expensive in V8. Decode into the two uint32 words backing
+    // Arrow Int64 instead; modulo-64 addition preserves every signed INT64 bit pattern exactly.
+    const state = new Uint32Array(2);
+    readZigZagVarIntWords(cursor, state);
+    return decodeDeltaBinaryPackedInt64ArrowValues(
+      cursor,
+      count,
+      miniBlockCount,
+      valuesPerMiniBlock,
+      output,
+      outputOffset,
+      state
+    );
+  }
   let value = readZigZagVarInt(cursor);
   let outputIndex = 0;
   writeInt64Output(output, outputOffset + outputIndex++, value, options.int64AsBigInt);
@@ -371,6 +434,254 @@ function decodeDeltaBinaryPackedInt64Values(
   return output;
 }
 
+/** Decodes INT64 directly into Arrow storage with modulo-64 two-word arithmetic. */
+function decodeDeltaBinaryPackedInt64ArrowValues(
+  cursor: CursorBuffer,
+  count: number,
+  miniBlockCount: number,
+  valuesPerMiniBlock: number,
+  output: BigInt64Array,
+  outputOffset: number,
+  state: Uint32Array
+): BigInt64Array {
+  const outputWords = new Uint32Array(output.buffer, output.byteOffset, output.length * 2);
+  const minimumDeltaWords = new Uint32Array(2);
+  let outputIndex = 0;
+  writeInt64Words(outputWords, outputOffset + outputIndex++, state[0], state[1]);
+
+  while (outputIndex < count) {
+    readZigZagVarIntWords(cursor, minimumDeltaWords);
+    const bitWidths = readBitWidths(cursor, miniBlockCount, 64);
+    const activeMiniBlockCount = Math.min(
+      miniBlockCount,
+      Math.ceil((count - outputIndex) / valuesPerMiniBlock)
+    );
+    // Preserve the equal-width fusion used by the wide-column benchmark. Splitting this back into
+    // four mini-block calls repeats state loads/stores and loses measurable throughput.
+    if (haveEqualBitWidths(bitWidths, activeMiniBlockCount)) {
+      const bitWidth = bitWidths[0];
+      const valueCount = Math.min(valuesPerMiniBlock * activeMiniBlockCount, count - outputIndex);
+      const packedByteLength = (valuesPerMiniBlock * activeMiniBlockCount * bitWidth) / 8;
+      assertReadable(cursor, packedByteLength);
+      decodeInt64ArrowMiniBlock(
+        cursor.buffer,
+        cursor.offset,
+        bitWidth,
+        valueCount,
+        minimumDeltaWords[0],
+        minimumDeltaWords[1],
+        state,
+        outputWords,
+        outputOffset + outputIndex
+      );
+      outputIndex += valueCount;
+      cursor.offset += packedByteLength;
+      continue;
+    }
+    for (const bitWidth of bitWidths) {
+      const packedOffset = cursor.offset;
+      const packedByteLength = (valuesPerMiniBlock * bitWidth) / 8;
+      assertReadable(cursor, packedByteLength);
+      const valueCount = Math.min(valuesPerMiniBlock, count - outputIndex);
+      decodeInt64ArrowMiniBlock(
+        cursor.buffer,
+        packedOffset,
+        bitWidth,
+        valueCount,
+        minimumDeltaWords[0],
+        minimumDeltaWords[1],
+        state,
+        outputWords,
+        outputOffset + outputIndex
+      );
+      outputIndex += valueCount;
+      cursor.offset += packedByteLength;
+      if (outputIndex === count) break;
+    }
+  }
+  return output;
+}
+
+/** Returns whether all mini-blocks in one DELTA_BINARY_PACKED block use one bit width. */
+function haveEqualBitWidths(bitWidths: Uint8Array, count: number): boolean {
+  const firstBitWidth = bitWidths[0];
+  for (let index = 1; index < count; index++) {
+    if (bitWidths[index] !== firstBitWidth) return false;
+  }
+  return true;
+}
+
+/** Decodes one INT64 mini-block directly into the two 32-bit words backing Arrow Int64. */
+function decodeInt64ArrowMiniBlock(
+  buffer: Uint8Array,
+  packedOffset: number,
+  bitWidth: number,
+  count: number,
+  minimumDeltaLow: number,
+  minimumDeltaHigh: number,
+  state: Uint32Array,
+  outputWords: Uint32Array,
+  outputOffset: number
+): void {
+  let stateLow = state[0];
+  let stateHigh = state[1];
+  const lowWordOffset = IS_LITTLE_ENDIAN ? 0 : 1;
+  const highWordOffset = IS_LITTLE_ENDIAN ? 1 : 0;
+
+  if (bitWidth === 0) {
+    for (let index = 0; index < count; index++) {
+      const lowSum = stateLow + minimumDeltaLow;
+      stateLow = lowSum >>> 0;
+      // V8 strength-reduces division by this constant; explicit carry branches benchmark slower.
+      stateHigh = (stateHigh + minimumDeltaHigh + Math.floor(lowSum / UINT32_BASE)) >>> 0;
+      const wordOffset = (outputOffset + index) * 2;
+      outputWords[wordOffset + lowWordOffset] = stateLow;
+      outputWords[wordOffset + highWordOffset] = stateHigh;
+    }
+    state[0] = stateLow;
+    state[1] = stateHigh;
+    return;
+  }
+
+  if (bitWidth <= 24) {
+    decodeNarrowInt64ArrowMiniBlock(
+      buffer,
+      packedOffset,
+      bitWidth,
+      count,
+      minimumDeltaLow,
+      minimumDeltaHigh,
+      state,
+      outputWords,
+      outputOffset
+    );
+    return;
+  }
+
+  if (bitWidth <= 45) {
+    const divisor = 2 ** bitWidth;
+    let packedBits = 0;
+    let packedBitCount = 0;
+    let byteOffset = packedOffset;
+    for (let index = 0; index < count; index++) {
+      while (packedBitCount < bitWidth) {
+        packedBits += buffer[byteOffset++] * 2 ** packedBitCount;
+        packedBitCount += 8;
+      }
+      const packedDelta = packedBits % divisor;
+      packedBits = Math.floor(packedBits / divisor);
+      packedBitCount -= bitWidth;
+      const packedDeltaLow = packedDelta >>> 0;
+      const packedDeltaHigh = Math.floor(packedDelta / UINT32_BASE);
+      const lowSum = stateLow + minimumDeltaLow + packedDeltaLow;
+      stateLow = lowSum >>> 0;
+      // V8 strength-reduces division by this constant; explicit carry branches benchmark slower.
+      stateHigh =
+        (stateHigh + minimumDeltaHigh + packedDeltaHigh + Math.floor(lowSum / UINT32_BASE)) >>> 0;
+      const wordOffset = (outputOffset + index) * 2;
+      outputWords[wordOffset + lowWordOffset] = stateLow;
+      outputWords[wordOffset + highWordOffset] = stateHigh;
+    }
+    state[0] = stateLow;
+    state[1] = stateHigh;
+    return;
+  }
+
+  const highBitWidth = bitWidth - 32;
+  const highMask = highBitWidth === 32 ? 0xffff_ffff : 2 ** highBitWidth - 1;
+  for (let index = 0; index < count; index++) {
+    const packedBitOffset = index * bitWidth;
+    const byteOffset = packedOffset + Math.floor(packedBitOffset / 8);
+    const shift = packedBitOffset & 7;
+    const lowerWord = readUint32LELoose(buffer, byteOffset);
+    const middleWord = readUint32LELoose(buffer, byteOffset + 4);
+    let packedDeltaLow: number;
+    let packedDeltaHigh: number;
+    if (shift === 0) {
+      packedDeltaLow = lowerWord;
+      packedDeltaHigh = middleWord & highMask;
+    } else {
+      const upperByte = buffer[byteOffset + 8] ?? 0;
+      packedDeltaLow = ((lowerWord >>> shift) | (middleWord << (32 - shift))) >>> 0;
+      packedDeltaHigh = ((middleWord >>> shift) | (upperByte << (32 - shift))) & highMask;
+    }
+    const lowSum = stateLow + minimumDeltaLow + packedDeltaLow;
+    stateLow = lowSum >>> 0;
+    // V8 strength-reduces division by this constant; explicit carry branches benchmark slower.
+    stateHigh =
+      (stateHigh + minimumDeltaHigh + packedDeltaHigh + Math.floor(lowSum / UINT32_BASE)) >>> 0;
+    const wordOffset = (outputOffset + index) * 2;
+    outputWords[wordOffset + lowWordOffset] = stateLow;
+    outputWords[wordOffset + highWordOffset] = stateHigh;
+  }
+  state[0] = stateLow;
+  state[1] = stateHigh;
+}
+
+/** Decodes an INT64 mini-block whose packed deltas fit a 32-bit bit reservoir. */
+function decodeNarrowInt64ArrowMiniBlock(
+  buffer: Uint8Array,
+  packedOffset: number,
+  bitWidth: number,
+  count: number,
+  minimumDeltaLow: number,
+  minimumDeltaHigh: number,
+  state: Uint32Array,
+  outputWords: Uint32Array,
+  outputOffset: number
+): void {
+  const mask = 2 ** bitWidth - 1;
+  const lowWordOffset = IS_LITTLE_ENDIAN ? 0 : 1;
+  const highWordOffset = IS_LITTLE_ENDIAN ? 1 : 0;
+  let stateLow = state[0];
+  let stateHigh = state[1];
+  let packedBits = 0;
+  let packedBitCount = 0;
+  let byteOffset = packedOffset;
+
+  for (let index = 0; index < count; index++) {
+    while (packedBitCount < bitWidth) {
+      packedBits |= buffer[byteOffset++] << packedBitCount;
+      packedBitCount += 8;
+    }
+    const packedDelta = packedBits & mask;
+    packedBits >>>= bitWidth;
+    packedBitCount -= bitWidth;
+    const lowSum = stateLow + minimumDeltaLow + packedDelta;
+    stateLow = lowSum >>> 0;
+    // V8 strength-reduces division by this constant; explicit carry branches benchmark slower.
+    stateHigh = (stateHigh + minimumDeltaHigh + Math.floor(lowSum / UINT32_BASE)) >>> 0;
+    const wordOffset = (outputOffset + index) * 2;
+    outputWords[wordOffset + lowWordOffset] = stateLow;
+    outputWords[wordOffset + highWordOffset] = stateHigh;
+  }
+  state[0] = stateLow;
+  state[1] = stateHigh;
+}
+
+/** Reads an unaligned little-endian word, treating bytes beyond a mini-block as zero. */
+function readUint32LELoose(buffer: Uint8Array, offset: number): number {
+  return (
+    ((buffer[offset] ?? 0) |
+      ((buffer[offset + 1] ?? 0) << 8) |
+      ((buffer[offset + 2] ?? 0) << 16) |
+      ((buffer[offset + 3] ?? 0) << 24)) >>>
+    0
+  );
+}
+
+/** Writes one pair of 32-bit words into a platform-endian BigInt64Array backing buffer. */
+function writeInt64Words(
+  outputWords: Uint32Array,
+  outputIndex: number,
+  low: number,
+  high: number
+): void {
+  const wordOffset = outputIndex * 2;
+  outputWords[wordOffset + (IS_LITTLE_ENDIAN ? 0 : 1)] = low;
+  outputWords[wordOffset + (IS_LITTLE_ENDIAN ? 1 : 0)] = high;
+}
+
 /** Decodes one INT64 mini-block, using numbers whenever the packed value remains exact. */
 function decodeInt64MiniBlock(
   buffer: Uint8Array,
@@ -457,14 +768,49 @@ export function decodeDeltaLengthByteArrayValues(
   options: ParquetCodecOptions
 ): ParquetValueBuffer {
   assertByteArrayType(type, 'DELTA_LENGTH_BYTE_ARRAY');
-  const lengths = decodeDeltaBinaryPackedValues('INT32', cursor, count, {});
+  const lengths = new Int32Array(count);
+  decodeDeltaBinaryPackedValues('INT32', cursor, count, {output: lengths});
+  if (options.byteArrayOutput) {
+    return decodeDeltaLengthByteArraysToContiguousOutput(cursor, lengths, options);
+  }
   const {output, outputOffset} = getParquetValueOutput(options, count);
   for (let index = 0; index < count; index++) {
-    output[outputOffset + index] = readByteArray(cursor, Number(lengths[index]));
+    output[outputOffset + index] = readByteArray(cursor, lengths[index]);
   }
   return output;
 }
 
+/** Copies DELTA_LENGTH_BYTE_ARRAY's contiguous payload directly into an Arrow byte buffer. */
+function decodeDeltaLengthByteArraysToContiguousOutput(
+  cursor: CursorBuffer,
+  lengths: Int32Array,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const byteArrayOutput = options.byteArrayOutput!;
+  const outputOffset = options.outputOffset || 0;
+  let payloadByteLength = 0;
+  for (const length of lengths) {
+    if (length < 0) {
+      throw new Error(`Invalid delta byte-array length ${length}`);
+    }
+    payloadByteLength += length;
+  }
+  assertReadable(cursor, payloadByteLength);
+  reserveParquetByteArrayOutput(byteArrayOutput, payloadByteLength);
+
+  let byteOffset = byteArrayOutput.byteLength;
+  byteArrayOutput.valueOffsets[outputOffset] = byteOffset;
+  const payloadEnd = cursor.offset + payloadByteLength;
+  byteArrayOutput.data.set(cursor.buffer.subarray(cursor.offset, payloadEnd), byteOffset);
+  cursor.offset = payloadEnd;
+  for (let valueIndex = 0; valueIndex < lengths.length; valueIndex++) {
+    byteOffset += lengths[valueIndex];
+    byteArrayOutput.valueOffsets[outputOffset + valueIndex + 1] = byteOffset;
+  }
+  byteArrayOutput.byteLength = byteOffset;
+  return options.output || [];
+}
+
 /** Decodes prefix lengths and delta-length suffixes into complete byte-array values. */
 export function decodeDeltaByteArrayValues(
   type: PrimitiveType,
@@ -473,17 +819,25 @@ export function decodeDeltaByteArrayValues(
   options: ParquetCodecOptions
 ): ParquetValueBuffer {
   assertByteArrayType(type, 'DELTA_BYTE_ARRAY');
-  const prefixLengths = decodeDeltaBinaryPackedValues('INT32', cursor, count, {});
-  const suffixes = decodeDeltaLengthByteArrayValues(type, cursor, count, {});
+  // One combined allocation is faster than separate prefix/suffix buffers in V8. Keep the two
+  // subarray views: reusing Arrow offsets as scratch storage deoptimizes reconstruction.
+  const lengths = new Int32Array(count * 2);
+  const prefixLengths = lengths.subarray(0, count);
+  const suffixLengths = lengths.subarray(count);
+  decodeDeltaBinaryPackedValues('INT32', cursor, count, {output: prefixLengths});
+  decodeDeltaBinaryPackedValues('INT32', cursor, count, {output: suffixLengths});
+  if (options.byteArrayOutput) {
+    return decodeDeltaByteArraysToContiguousOutput(cursor, prefixLengths, suffixLengths, options);
+  }
   const {output, outputOffset} = getParquetValueOutput(options, count);
   let previousValue: Uint8Array | undefined;
 
   for (let index = 0; index < count; index++) {
-    const prefixLength = Number(prefixLengths[index]);
-    const suffix = suffixes[index] as Uint8Array;
+    const prefixLength = prefixLengths[index];
     if (prefixLength < 0 || (prefixLength > 0 && prefixLength > (previousValue?.length || 0))) {
       throw new Error(`Invalid DELTA_BYTE_ARRAY prefix length ${prefixLength}`);
     }
+    const suffix = readByteArray(cursor, suffixLengths[index]);
     if (prefixLength === 0) {
       output[outputOffset + index] = suffix;
       previousValue = suffix;
@@ -499,6 +853,76 @@ export function decodeDeltaByteArrayValues(
   return output;
 }
 
+/** Reconstructs DELTA_BYTE_ARRAY values directly in one Arrow-compatible byte buffer. */
+function decodeDeltaByteArraysToContiguousOutput(
+  cursor: CursorBuffer,
+  prefixLengths: Int32Array,
+  suffixLengths: Int32Array,
+  options: ParquetCodecOptions
+): ParquetValueBuffer {
+  const byteArrayOutput = options.byteArrayOutput!;
+  const outputOffset = options.outputOffset || 0;
+  let byteOffset = byteArrayOutput.byteLength;
+  let previousValueOffset = byteOffset;
+  let previousValueLength = 0;
+  byteArrayOutput.valueOffsets[outputOffset] = byteOffset;
+
+  let requiredByteLength = 0;
+  let requiredSuffixByteLength = 0;
+  for (let valueIndex = 0; valueIndex < prefixLengths.length; valueIndex++) {
+    const prefixLength = prefixLengths[valueIndex];
+    const suffixLength = suffixLengths[valueIndex];
+    if (prefixLength < 0 || prefixLength > previousValueLength) {
+      throw new Error(`Invalid DELTA_BYTE_ARRAY prefix length ${prefixLength}`);
+    }
+    if (suffixLength < 0) {
+      throw new Error(`Invalid delta byte-array length ${suffixLength}`);
+    }
+    previousValueLength = prefixLength + suffixLength;
+    requiredByteLength += previousValueLength;
+    requiredSuffixByteLength += suffixLength;
+  }
+  assertReadable(cursor, requiredSuffixByteLength);
+  reserveParquetByteArrayOutput(byteArrayOutput, requiredByteLength);
+
+  const data = byteArrayOutput.data;
+  const valueOffsets = byteArrayOutput.valueOffsets;
+  const inputBuffer = cursor.buffer;
+  let inputOffset = cursor.offset;
+  previousValueLength = 0;
+  for (let valueIndex = 0; valueIndex < prefixLengths.length; valueIndex++) {
+    const prefixLength = prefixLengths[valueIndex];
+    const suffixLength = suffixLengths[valueIndex];
+    const valueLength = prefixLength + suffixLength;
+    if (prefixLength > 0) {
+      if (prefixLength <= 15) {
+        for (let byteIndex = 0; byteIndex < prefixLength; byteIndex++) {
+          data[byteOffset + byteIndex] = data[previousValueOffset + byteIndex];
+        }
+      } else {
+        data.copyWithin(byteOffset, previousValueOffset, previousValueOffset + prefixLength);
+      }
+    }
+    const suffixEnd = inputOffset + suffixLength;
+    if (suffixLength <= 15) {
+      let suffixOutputOffset = byteOffset + prefixLength;
+      while (inputOffset < suffixEnd) {
+        data[suffixOutputOffset++] = inputBuffer[inputOffset++];
+      }
+    } else {
+      data.set(inputBuffer.subarray(inputOffset, suffixEnd), byteOffset + prefixLength);
+      inputOffset = suffixEnd;
+    }
+    previousValueOffset = byteOffset;
+    previousValueLength = valueLength;
+    byteOffset += valueLength;
+    valueOffsets[outputOffset + valueIndex + 1] = byteOffset;
+  }
+  cursor.offset = inputOffset;
+  byteArrayOutput.byteLength = byteOffset;
+  return options.output || [];
+}
+
 /** Reads and validates a sequence of one-byte mini-block bit widths. */
 function readBitWidths(cursor: CursorBuffer, count: number, maximumBitWidth: number): Uint8Array {
   assertReadable(cursor, count);
@@ -512,6 +936,42 @@ function readBitWidths(cursor: CursorBuffer, count: number, maximumBitWidth: num
   return bitWidths;
 }
 
+/** Reads one signed zig-zag INT64 directly into its low and high two's-complement words. */
+function readZigZagVarIntWords(cursor: CursorBuffer, words: Uint32Array): void {
+  let low = 0;
+  let high = 0;
+  for (let byteIndex = 0; byteIndex < 10; byteIndex++) {
+    assertReadable(cursor, 1);
+    const byte = cursor.buffer[cursor.offset++];
+    const payload = byte & 0x7f;
+    const bitOffset = byteIndex * 7;
+    if (byteIndex === 9 && payload > 1) {
+      throw new Error('Invalid Parquet variable-length integer');
+    }
+    if (bitOffset < 32) {
+      low |= payload << bitOffset;
+      if (bitOffset > 25) {
+        high |= payload >>> (32 - bitOffset);
+      }
+    } else {
+      high |= payload << (bitOffset - 32);
+    }
+    if ((byte & 0x80) === 0) {
+      const negative = low & 1;
+      let decodedLow = ((low >>> 1) | ((high & 1) << 31)) >>> 0;
+      let decodedHigh = high >>> 1;
+      if (negative) {
+        decodedLow = ~decodedLow >>> 0;
+        decodedHigh = ~decodedHigh >>> 0;
+      }
+      words[0] = decodedLow;
+      words[1] = decodedHigh;
+      return;
+    }
+  }
+  throw new Error('Invalid Parquet variable-length integer');
+}
+
 /** Reads an unsigned base-128 variable-length integer. */
 function readUnsignedVarInt(cursor: CursorBuffer): bigint {
   let value = 0n;

package/src/parquetjs/codecs/index.ts

@@ -23,6 +23,10 @@ export const PARQUET_CODECS: Record<ParquetCodec, ParquetCodecKit> = {
     encodeValues: RLE.encodeValues,
     decodeValues: RLE.decodeValues
   },
+  BIT_PACKED: {
+    encodeValues: RLE.encodeBitPackedValues,
+    decodeValues: RLE.decodeBitPackedValues
+  },
   // Using the PLAIN_DICTIONARY enum value is deprecated in the Parquet 2.0 specification.
   PLAIN_DICTIONARY: {
     // @ts-ignore