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

package/src/parquetjs/schema/schema.ts

@@ -5,6 +5,8 @@
 // Forked from https://github.com/kbajalc/parquets under MIT license
 
 import {PARQUET_CODECS} from '../codecs/index';
+import {isByteStreamSplitType} from '../codecs/byte-stream-split';
+import {isDeltaEncodingType} from '../codecs/delta';
 import {PARQUET_COMPRESSION_METHODS} from '../compression';
 import {
   FieldDefinition,
@@ -15,7 +17,8 @@ import {
   RepetitionType,
   SchemaDefinition
 } from './declare';
-import {materializeRows, shredBuffer, shredRecord} from './shred';
+import type {ArrayType} from '@loaders.gl/schema';
+import {materializeColumns, materializeRows, shredBuffer, shredRecord} from './shred';
 import {PARQUET_LOGICAL_TYPES} from './types';
 
 /**
@@ -82,6 +85,11 @@ export class ParquetSchema {
     return materializeRows(this, rowGroup);
   }
 
+  /** Materializes one decoded row group as top-level column arrays. */
+  materializeColumns(rowGroup: ParquetRowGroup): Record<string, ArrayType> {
+    return materializeColumns(this, rowGroup);
+  }
+
   compress(type: ParquetCompression): this {
     setCompress(this.schema, type);
     setCompress(this.fields, type);
@@ -140,6 +148,8 @@ function buildFields(
         name,
         path: cpath,
         key: cpath.join(),
+        logicalType: opts.logicalType,
+        fieldId: opts.fieldId,
         repetitionType,
         rLevelMax,
         dLevelMax,
@@ -159,6 +169,13 @@ function buildFields(
     if (!(opts.encoding in PARQUET_CODECS)) {
       throw new Error(`unsupported parquet encoding: ${opts.encoding}`);
     }
+    const primitiveType = opts.physicalType || typeDef.primitiveType;
+    if (opts.encoding === 'BYTE_STREAM_SPLIT' && !isByteStreamSplitType(primitiveType)) {
+      throw new Error(`BYTE_STREAM_SPLIT does not support ${primitiveType}`);
+    }
+    if (opts.encoding.startsWith('DELTA_') && !isDeltaEncodingType(opts.encoding, primitiveType)) {
+      throw new Error(`${opts.encoding} does not support ${primitiveType}`);
+    }
 
     opts.compression = opts.compression || 'UNCOMPRESSED';
     if (!(opts.compression in PARQUET_COMPRESSION_METHODS)) {
@@ -169,15 +186,18 @@ function buildFields(
     const cpath = path.concat([name]);
     fieldList[name] = {
       name,
-      primitiveType: typeDef.primitiveType,
+      primitiveType,
       originalType: typeDef.originalType,
+      logicalType: opts.logicalType,
+      fieldId: opts.fieldId,
       path: cpath,
       key: cpath.join(),
       repetitionType,
       encoding: opts.encoding,
       compression: opts.compression,
       typeLength: opts.typeLength || typeDef.typeLength,
-      presision: opts.presision,
+      presision: opts.precision ?? opts.presision,
+      precision: opts.precision ?? opts.presision,
       scale: opts.scale,
       rLevelMax,
       dLevelMax

package/src/parquetjs/schema/shred.ts

@@ -65,9 +65,18 @@ export function shredRecord(
   }
   rowGroup.rowCount += 1;
   for (const field of schema.fieldList) {
-    Array.prototype.push.apply(rowGroup.columnData[field.key].rlevels, data[field.key].rlevels);
-    Array.prototype.push.apply(rowGroup.columnData[field.key].dlevels, data[field.key].dlevels);
-    Array.prototype.push.apply(rowGroup.columnData[field.key].values, data[field.key].values);
+    Array.prototype.push.apply(
+      rowGroup.columnData[field.key].rlevels as number[],
+      data[field.key].rlevels as number[]
+    );
+    Array.prototype.push.apply(
+      rowGroup.columnData[field.key].dlevels as number[],
+      data[field.key].dlevels as number[]
+    );
+    Array.prototype.push.apply(
+      rowGroup.columnData[field.key].values as unknown[],
+      data[field.key].values as unknown as unknown[]
+    );
     rowGroup.columnData[field.key].count += data[field.key].count;
   }
 }
@@ -111,8 +120,8 @@ function shredRecordFields(
         shredRecordFields(field.fields!, null!, data, rLevel, dLevel);
       } else {
         data[field.key].count += 1;
-        data[field.key].rlevels.push(rLevel);
-        data[field.key].dlevels.push(dLevel);
+        (data[field.key].rlevels as number[]).push(rLevel);
+        (data[field.key].dlevels as number[]).push(dLevel);
       }
       continue; // eslint-disable-line no-continue
     }
@@ -124,10 +133,10 @@ function shredRecordFields(
         shredRecordFields(field.fields!, values[i], data, rlvl, field.dLevelMax);
       } else {
         data[field.key].count += 1;
-        data[field.key].rlevels.push(rlvl);
-        data[field.key].dlevels.push(field.dLevelMax);
-        data[field.key].values.push(
-          Types.toPrimitive((field.originalType || field.primitiveType)!, values[i])
+        (data[field.key].rlevels as number[]).push(rlvl);
+        (data[field.key].dlevels as number[]).push(field.dLevelMax);
+        (data[field.key].values as unknown[]).push(
+          Types.toPrimitive((field.originalType || field.primitiveType)!, values[i], field)
         );
       }
     }
@@ -154,10 +163,9 @@ function shredRecordFields(
  *   }
  */
 export function materializeRows(schema: ParquetSchema, rowGroup: ParquetRowGroup): ParquetRow[] {
-  const rows: ParquetRow[] = [];
-  // rows = new Array(rowGroup.rowCount).fill({})'
+  const rows = new Array<ParquetRow>(rowGroup.rowCount);
   for (let i = 0; i < rowGroup.rowCount; i++) {
-    rows.push({});
+    rows[i] = {};
   }
   for (const key in rowGroup.columnData) {
     const columnData = rowGroup.columnData[key];
@@ -179,6 +187,14 @@ function materializeColumnAsRows(
   const field = schema.findField(key);
   const branch = schema.findFieldBranch(key);
 
+  if (branch.length === 1 && field.repetitionType !== 'REPEATED') {
+    materializeFlatColumnAsRows(field, columnData, rows);
+    return;
+  }
+
+  const logicalType = field.originalType || field.primitiveType!;
+  const fromPrimitive = Types.PARQUET_LOGICAL_TYPES[logicalType].fromPrimitive;
+
   // tslint:disable-next-line:prefer-array-literal
   const rLevels: number[] = new Array(field.rLevelMax + 1).fill(0);
   let vIndex = 0;
@@ -219,12 +235,8 @@ function materializeColumnAsRows(
 
     // Leaf node - Add the value
     if (dLevel === field.dLevelMax) {
-      const value = Types.fromPrimitive(
-        // @ts-ignore
-        field.originalType || field.primitiveType,
-        columnData.values[vIndex],
-        field
-      );
+      const primitiveValue = columnData.values[vIndex];
+      const value = fromPrimitive ? fromPrimitive(primitiveValue, field) : primitiveValue;
       vIndex++;
 
       switch (field.repetitionType) {
@@ -248,6 +260,35 @@ function materializeColumnAsRows(
   }
 }
 
+/** Materializes a top-level required or optional primitive directly into row objects. */
+function materializeFlatColumnAsRows(
+  field: ParquetField,
+  columnData: ParquetColumnChunk,
+  rows: ParquetRow[]
+): void {
+  const logicalType = field.originalType || field.primitiveType!;
+  const fromPrimitive = Types.PARQUET_LOGICAL_TYPES[logicalType].fromPrimitive;
+  const count = Math.min(columnData.count, rows.length);
+  let valueIndex = 0;
+
+  if (field.repetitionType === 'REQUIRED' && !fromPrimitive) {
+    for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+      rows[rowIndex][field.name] = columnData.values[rowIndex];
+    }
+    return;
+  }
+
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    if (columnData.dlevels[rowIndex] === field.dLevelMax) {
+      const primitiveValue = columnData.values[valueIndex];
+      rows[rowIndex][field.name] = fromPrimitive
+        ? fromPrimitive(primitiveValue, field)
+        : primitiveValue;
+      valueIndex++;
+    }
+  }
+}
+
 // Columnar export
 
 /**
@@ -275,14 +316,30 @@ export function materializeColumns(
 ): Record<string, ArrayType> {
   const columns: Record<string, ArrayType> = {};
   for (const key in rowGroup.columnData) {
-    const columnData = rowGroup.columnData[key];
-    if (columnData.count) {
-      materializeColumnAsColumnarArray(schema, columnData, rowGroup.rowCount, key, columns);
+    const column = materializeColumn(schema, rowGroup, key);
+    if (column) {
+      columns[schema.findFieldBranch(key)[0].name] = column;
     }
   }
   return columns;
 }
 
+/** Materializes one decoded Parquet column into its top-level columnar representation. */
+export function materializeColumn(
+  schema: ParquetSchema,
+  rowGroup: ParquetRowGroup,
+  key: string
+): ArrayType | undefined {
+  const columnData = rowGroup.columnData[key];
+  if (!columnData?.count) {
+    return undefined;
+  }
+
+  const columns: Record<string, ArrayType> = {};
+  materializeColumnAsColumnarArray(schema, columnData, rowGroup.rowCount, key, columns);
+  return columns[schema.findFieldBranch(key)[0].name];
+}
+
 // eslint-disable-next-line max-statements, complexity
 function materializeColumnAsColumnarArray(
   schema: ParquetSchema,
@@ -300,23 +357,12 @@ function materializeColumnAsColumnarArray(
 
   const columnName = branch[0].name;
 
-  let column: ArrayType | undefined;
-  const {values} = columnData;
-  if (values.length === rowCount && branch[0].primitiveType) {
-    // if (branch[0].repetitionType === `REQUIRED`) {
-    //   switch (branch[0].primitiveType) {
-    //     case 'INT32': return values instanceof Int32Array ? values : new Int32Array(values);
-    //   }
-    // }
-    column = values;
-  }
-
-  if (column) {
-    columns[columnName] = column;
+  if (branch.length === 1 && field.repetitionType !== 'REPEATED') {
+    columns[columnName] = materializeFlatColumn(field, columnData, rowCount);
     return;
   }
 
-  column = new Array(rowCount);
+  const column: ArrayType = new Array(rowCount);
   for (let i = 0; i < rowCount; i++) {
     column[i] = {};
   }
@@ -397,3 +443,34 @@ function materializeColumnAsColumnarArray(
     }
   }
 }
+
+/** Materializes a required or optional top-level primitive column with logical type conversion. */
+function materializeFlatColumn(
+  field: ParquetField,
+  columnData: ParquetColumnChunk,
+  rowCount: number
+): ArrayType {
+  const logicalType = field.originalType || field.primitiveType!;
+  const fromPrimitive = Types.PARQUET_LOGICAL_TYPES[logicalType].fromPrimitive;
+  const count = Math.min(columnData.count, rowCount);
+
+  if (
+    field.repetitionType === 'REQUIRED' &&
+    !fromPrimitive &&
+    count === rowCount &&
+    columnData.values.length === rowCount
+  ) {
+    return columnData.values;
+  }
+
+  const column = new Array(rowCount).fill(null);
+  let valueIndex = 0;
+  for (let rowIndex = 0; rowIndex < count; rowIndex++) {
+    if (columnData.dlevels[rowIndex] === field.dLevelMax) {
+      const primitiveValue = columnData.values[valueIndex];
+      column[rowIndex] = fromPrimitive ? fromPrimitive(primitiveValue, field) : primitiveValue;
+      valueIndex++;
+    }
+  }
+  return column;
+}

package/src/parquetjs/schema/types.ts

@@ -64,6 +64,12 @@ export const PARQUET_LOGICAL_TYPES: Record<ParquetType, ParquetTypeKit> = {
     toPrimitive: toPrimitive_UTF8,
     fromPrimitive: fromPrimitive_UTF8
   },
+  ENUM: {
+    primitiveType: 'BYTE_ARRAY',
+    originalType: 'ENUM',
+    toPrimitive: toPrimitive_UTF8,
+    fromPrimitive: fromPrimitive_UTF8
+  },
   TIME_MILLIS: {
     primitiveType: 'INT32',
     originalType: 'TIME_MILLIS',
@@ -74,6 +80,11 @@ export const PARQUET_LOGICAL_TYPES: Record<ParquetType, ParquetTypeKit> = {
     originalType: 'TIME_MICROS',
     toPrimitive: toPrimitive_TIME_MICROS
   },
+  TIME_NANOS: {
+    primitiveType: 'INT64',
+    originalType: 'TIME_NANOS',
+    toPrimitive: toPrimitive_TIME_NANOS
+  },
   DATE: {
     primitiveType: 'INT32',
     originalType: 'DATE',
@@ -92,6 +103,11 @@ export const PARQUET_LOGICAL_TYPES: Record<ParquetType, ParquetTypeKit> = {
     toPrimitive: toPrimitive_TIMESTAMP_MICROS,
     fromPrimitive: fromPrimitive_TIMESTAMP_MICROS
   },
+  TIMESTAMP_NANOS: {
+    primitiveType: 'INT64',
+    originalType: 'TIMESTAMP_NANOS',
+    toPrimitive: toPrimitive_TIMESTAMP_NANOS
+  },
   UINT_8: {
     primitiveType: 'INT32',
     originalType: 'UINT_8',
@@ -144,6 +160,39 @@ export const PARQUET_LOGICAL_TYPES: Record<ParquetType, ParquetTypeKit> = {
     toPrimitive: toPrimitive_BSON,
     fromPrimitive: fromPrimitive_BSON
   },
+  UUID: {
+    primitiveType: 'FIXED_LEN_BYTE_ARRAY',
+    originalType: 'UUID',
+    typeLength: 16,
+    toPrimitive: toPrimitive_BYTE_ARRAY
+  },
+  FLOAT16: {
+    primitiveType: 'FIXED_LEN_BYTE_ARRAY',
+    originalType: 'FLOAT16',
+    typeLength: 2,
+    toPrimitive: toPrimitive_FLOAT16,
+    fromPrimitive: fromPrimitive_FLOAT16
+  },
+  UNKNOWN: {
+    primitiveType: 'BYTE_ARRAY',
+    originalType: 'UNKNOWN',
+    toPrimitive: toPrimitive_BYTE_ARRAY
+  },
+  VARIANT: {
+    primitiveType: 'BYTE_ARRAY',
+    originalType: 'VARIANT',
+    toPrimitive: toPrimitive_BYTE_ARRAY
+  },
+  GEOMETRY: {
+    primitiveType: 'BYTE_ARRAY',
+    originalType: 'GEOMETRY',
+    toPrimitive: toPrimitive_BYTE_ARRAY
+  },
+  GEOGRAPHY: {
+    primitiveType: 'BYTE_ARRAY',
+    originalType: 'GEOGRAPHY',
+    toPrimitive: toPrimitive_BYTE_ARRAY
+  },
   INTERVAL: {
     primitiveType: 'FIXED_LEN_BYTE_ARRAY',
     originalType: 'INTERVAL',
@@ -221,6 +270,73 @@ function toPrimitive_FLOAT(value: any): number {
   return v;
 }
 
+/** Converts a JavaScript number to the two-byte IEEE 754 binary16 representation. */
+function toPrimitive_FLOAT16(value: unknown): Uint8Array {
+  const numberValue = Number(value);
+  if (Number.isNaN(numberValue) && !Number.isNaN(value)) {
+    throw new Error(`invalid value for FLOAT16: ${value}`);
+  }
+
+  const float32 = new Float32Array([numberValue]);
+  const bits = new Uint32Array(float32.buffer)[0];
+  const sign = (bits >>> 16) & 0x8000;
+  const exponent = (bits >>> 23) & 0xff;
+  const mantissa = bits & 0x7fffff;
+  let half: number;
+  if (exponent === 0xff) {
+    half = sign | 0x7c00 | (mantissa ? 0x0200 : 0);
+  } else {
+    const halfExponent = exponent - 127 + 15;
+    if (halfExponent >= 0x1f) {
+      half = sign | 0x7c00;
+    } else if (halfExponent <= 0) {
+      if (halfExponent < -10) {
+        half = sign;
+      } else {
+        const normalizedMantissa = mantissa | 0x800000;
+        half = sign | roundRightShiftToNearestEven(normalizedMantissa, 14 - halfExponent);
+      }
+    } else {
+      const halfMantissa = roundRightShiftToNearestEven(mantissa, 13);
+      if (halfMantissa === 0x400) {
+        const roundedExponent = halfExponent + 1;
+        half = roundedExponent >= 0x1f ? sign | 0x7c00 : sign | (roundedExponent << 10);
+      } else {
+        half = sign | (halfExponent << 10) | halfMantissa;
+      }
+    }
+  }
+  return new Uint8Array([half & 0xff, half >>> 8]);
+}
+
+/** Rounds a non-negative integer right shift using IEEE round-to-nearest, ties-to-even. */
+function roundRightShiftToNearestEven(value: number, shift: number): number {
+  const divisor = 2 ** shift;
+  const quotient = Math.floor(value / divisor);
+  const remainder = value - quotient * divisor;
+  const halfway = divisor / 2;
+  return quotient + (remainder > halfway || (remainder === halfway && quotient % 2 === 1) ? 1 : 0);
+}
+
+/** Converts little-endian IEEE 754 binary16 bytes to a JavaScript number. */
+function fromPrimitive_FLOAT16(value: unknown): number {
+  const bytes = toUint8Array(value as ArrayBuffer | ArrayBufferView);
+  if (bytes.byteLength !== 2) {
+    throw new Error(`invalid FLOAT16 byte length: ${bytes.byteLength}`);
+  }
+  const half = bytes[0] | (bytes[1] << 8);
+  const sign = half & 0x8000 ? -1 : 1;
+  const exponent = (half >>> 10) & 0x1f;
+  const mantissa = half & 0x03ff;
+  if (exponent === 0x1f) {
+    return mantissa ? Number.NaN : sign * Number.POSITIVE_INFINITY;
+  }
+  if (exponent === 0) {
+    return sign * 2 ** -14 * (mantissa / 1024);
+  }
+  return sign * 2 ** (exponent - 15) * (1 + mantissa / 1024);
+}
+
 function toPrimitive_DOUBLE(value: any): number {
   const v = parseFloat(value);
   if (Number.isNaN(v)) {
@@ -285,18 +401,30 @@ function decimalToPrimitive_INT32(value: number, field: ParquetField): number {
 
 function toPrimitive_UINT32(value: any): number {
   const v = parseInt(value, 10);
-  if (v < 0 || v > 0xffffffffffff || Number.isNaN(v)) {
+  if (v < 0 || v > 0xffffffff || Number.isNaN(v)) {
     throw new Error(`invalid value for UINT32: ${value}`);
   }
   return v;
 }
 
-function toPrimitive_INT64(value: any): number {
-  const v = parseInt(value, 10);
-  if (Number.isNaN(v)) {
+function toPrimitive_INT64(value: unknown): number | bigint {
+  if (typeof value === 'number') {
+    if (!Number.isSafeInteger(value)) {
+      throw new Error(`invalid value for INT64: ${value}`);
+    }
+    return value;
+  }
+
+  let primitiveValue: bigint;
+  try {
+    primitiveValue = BigInt(value as bigint | boolean | string);
+  } catch {
     throw new Error(`invalid value for INT64: ${value}`);
   }
-  return v;
+  if (primitiveValue < -(2n ** 63n) || primitiveValue > 2n ** 63n - 1n) {
+    throw new Error(`invalid value for INT64: ${value}`);
+  }
+  return primitiveValue;
 }
 
 function decimalToPrimitive_INT64(value: number, field: ParquetField) {
@@ -309,13 +437,12 @@ function decimalToPrimitive_INT64(value: number, field: ParquetField) {
   return v;
 }
 
-function toPrimitive_UINT64(value: any) {
-  const v = parseInt(value, 10);
-  if (v < 0 || Number.isNaN(v)) {
+function toPrimitive_UINT64(value: unknown): bigint {
+  const primitiveValue = BigInt(value as bigint | boolean | number | string);
+  if (primitiveValue < 0n || primitiveValue > 2n ** 64n - 1n) {
     throw new Error(`invalid value for UINT64: ${value}`);
   }
-
-  return v;
+  return BigInt.asIntN(64, primitiveValue);
 }
 
 function toPrimitive_INT96(value: any) {
@@ -331,9 +458,90 @@ function toPrimitive_BYTE_ARRAY(value: any): Uint8Array {
   return typeof value === 'string' ? encodeUtf8(value) : toUint8Array(value);
 }
 
-function decimalToPrimitive_BYTE_ARRAY(value: any): Uint8Array {
-  // TBD
-  return typeof value === 'string' ? encodeUtf8(value) : toUint8Array(value);
+function decimalToPrimitive_BYTE_ARRAY(value: unknown, field: ParquetField): Uint8Array {
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    const bytes = toUint8Array(value);
+    if (field.typeLength !== undefined && bytes.byteLength !== field.typeLength) {
+      throw new Error(
+        `invalid DECIMAL byte width: expected ${field.typeLength}, received ${bytes.byteLength}`
+      );
+    }
+    return bytes;
+  }
+
+  const unscaledValue = getUnscaledDecimalInteger(value, field.scale || 0);
+  const precision = field.precision ?? field.presision;
+  if (precision !== undefined && getDecimalDigitCount(unscaledValue) > precision) {
+    throw new Error(`DECIMAL value ${value} exceeds precision ${precision}`);
+  }
+  const byteWidth = field.typeLength ?? getSignedBigIntByteWidth(unscaledValue);
+  const bitWidth = BigInt(byteWidth * 8);
+  const minimum = -(1n << (bitWidth - 1n));
+  const maximum = (1n << (bitWidth - 1n)) - 1n;
+  if (unscaledValue < minimum || unscaledValue > maximum) {
+    throw new Error(`DECIMAL value ${value} does not fit in ${byteWidth} bytes`);
+  }
+
+  const bytes = new Uint8Array(byteWidth);
+  let unsignedValue = BigInt.asUintN(byteWidth * 8, unscaledValue);
+  for (let byteIndex = byteWidth - 1; byteIndex >= 0; byteIndex--) {
+    bytes[byteIndex] = Number(unsignedValue & 0xffn);
+    unsignedValue >>= 8n;
+  }
+  return bytes;
+}
+
+/** Converts a logical decimal value to its exact scaled integer. */
+function getUnscaledDecimalInteger(value: unknown, scale: number): bigint {
+  if (!Number.isInteger(scale) || scale < 0) {
+    throw new Error(`invalid DECIMAL scale: ${scale}`);
+  }
+  if (typeof value === 'bigint') {
+    return value * 10n ** BigInt(scale);
+  }
+  if (typeof value === 'number') {
+    const scaledValue = Math.round(value * 10 ** scale);
+    if (!Number.isFinite(value) || !Number.isSafeInteger(scaledValue)) {
+      throw new Error(`DECIMAL number ${value} cannot be represented exactly; use a string`);
+    }
+    return BigInt(scaledValue);
+  }
+  if (typeof value !== 'string') {
+    throw new Error(`invalid value for DECIMAL: ${value}`);
+  }
+
+  const match = /^([+-]?)(\d+)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(value.trim());
+  if (!match) {
+    throw new Error(`invalid value for DECIMAL: ${value}`);
+  }
+  const sign = match[1] === '-' ? -1n : 1n;
+  const fraction = match[3] || '';
+  let unscaledValue = BigInt(`${match[2]}${fraction}` || '0');
+  const decimalShift = scale + Number(match[4] || 0) - fraction.length;
+  if (decimalShift >= 0) {
+    unscaledValue *= 10n ** BigInt(decimalShift);
+  } else {
+    const divisor = 10n ** BigInt(-decimalShift);
+    if (unscaledValue % divisor !== 0n) {
+      throw new Error(`DECIMAL value ${value} has more fractional digits than scale ${scale}`);
+    }
+    unscaledValue /= divisor;
+  }
+  return sign * unscaledValue;
+}
+
+/** Returns the number of base-10 digits in a signed integer, treating zero as one digit. */
+function getDecimalDigitCount(value: bigint): number {
+  return (value < 0n ? -value : value).toString().length;
+}
+
+/** Returns the smallest two's-complement byte width that can contain a signed integer. */
+function getSignedBigIntByteWidth(value: bigint): number {
+  let byteWidth = 1;
+  while (value < -(1n << BigInt(byteWidth * 8 - 1)) || value >= 1n << BigInt(byteWidth * 8 - 1)) {
+    byteWidth++;
+  }
+  return byteWidth;
 }
 
 function toPrimitive_UTF8(value: any): Uint8Array {
@@ -364,20 +572,27 @@ function fromPrimitive_BSON(value: any) {
 
 function toPrimitive_TIME_MILLIS(value: any) {
   const v = parseInt(value, 10);
-  // eslint-disable-next-line @typescript-eslint/no-loss-of-precision
-  if (v < 0 || v > 0xffffffffffffffff || Number.isNaN(v)) {
+  if (v < 0 || v >= kMillisPerDay || Number.isNaN(v)) {
     throw new Error(`invalid value for TIME_MILLIS: ${value}`);
   }
 
   return v;
 }
 
-function toPrimitive_TIME_MICROS(value: any): number {
-  const v = parseInt(value, 10);
-  if (v < 0 || Number.isNaN(v)) {
+function toPrimitive_TIME_MICROS(value: unknown): bigint {
+  const primitiveValue = BigInt(value as bigint | boolean | number | string);
+  if (primitiveValue < 0n || primitiveValue >= 86_400_000_000n) {
     throw new Error(`invalid value for TIME_MICROS: ${value}`);
   }
-  return v;
+  return primitiveValue;
+}
+
+function toPrimitive_TIME_NANOS(value: unknown): bigint {
+  const primitiveValue = BigInt(value as bigint | boolean | number | string);
+  if (primitiveValue < 0n || primitiveValue >= 86_400_000_000_000n) {
+    throw new Error(`invalid value for TIME_NANOS: ${value}`);
+  }
+  return primitiveValue;
 }
 
 const kMillisPerDay = 86400000;
@@ -391,7 +606,7 @@ function toPrimitive_DATE(value: any): number {
   /* convert from integer */
   {
     const v = parseInt(value, 10);
-    if (v < 0 || Number.isNaN(v)) {
+    if (v < -0x80000000 || v > 0x7fffffff || Number.isNaN(v)) {
       throw new Error(`invalid value for DATE: ${value}`);
     }
 
@@ -412,7 +627,7 @@ function toPrimitive_TIMESTAMP_MILLIS(value: any): number {
   /* convert from integer */
   {
     const v = parseInt(value, 10);
-    if (v < 0 || Number.isNaN(v)) {
+    if (!Number.isSafeInteger(v)) {
       throw new Error(`invalid value for TIMESTAMP_MILLIS: ${value}`);
     }
 
@@ -421,28 +636,36 @@ function toPrimitive_TIMESTAMP_MILLIS(value: any): number {
 }
 
 function fromPrimitive_TIMESTAMP_MILLIS(value: any): Date {
-  return new Date(value);
+  return new Date(Number(value));
 }
 
-function toPrimitive_TIMESTAMP_MICROS(value: any) {
+function toPrimitive_TIMESTAMP_MICROS(value: unknown): bigint {
   /* convert from date */
   if (value instanceof Date) {
-    return value.getTime() * 1000;
+    return BigInt(value.getTime()) * 1000n;
   }
 
   /* convert from integer */
   {
-    const v = parseInt(value, 10);
-    if (v < 0 || Number.isNaN(v)) {
+    let primitiveValue: bigint;
+    try {
+      primitiveValue = BigInt(value as bigint | boolean | number | string);
+    } catch {
       throw new Error(`invalid value for TIMESTAMP_MICROS: ${value}`);
     }
-
-    return v;
+    return primitiveValue;
   }
 }
 
 function fromPrimitive_TIMESTAMP_MICROS(value: any) {
-  return new Date(value / 1000);
+  return new Date(Number(value) / 1000);
+}
+
+function toPrimitive_TIMESTAMP_NANOS(value: unknown): bigint {
+  if (value instanceof Date) {
+    return BigInt(value.getTime()) * 1_000_000n;
+  }
+  return BigInt(value as bigint | boolean | number | string);
 }
 
 function toPrimitive_INTERVAL(value: any) {
@@ -470,8 +693,10 @@ function fromPrimitive_INTERVAL(value: any) {
 }
 
 function decimalFromPrimitive_INT(value: any, field: ParquetField) {
-  const presisionInt = Math.round(((value * 10 ** -field.presision!) % 1) * 10 ** field.presision!);
-  return presisionInt * 10 ** -(field.scale || 0);
+  const numberValue = Number(value);
+  const precision = field.precision ?? field.presision!;
+  const precisionInt = Math.round(((numberValue * 10 ** -precision) % 1) * 10 ** precision);
+  return precisionInt * 10 ** -(field.scale || 0);
 }
 
 function decimalFromPrimitive_BYTE_ARRAY(value: any, field: ParquetField) {