@loaders.gl/parquet 4.5.3 → 5.0.0-alpha.10

package/src/iceberg-types.ts

@@ -0,0 +1,165 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Minimal Iceberg table metadata shape needed for read-only table discovery. */
+export type IcebergTableMetadata = {
+  /** Iceberg metadata format version. */
+  readonly 'format-version': 1 | 2 | 3;
+  /** Table UUID when supplied by the writer. */
+  readonly 'table-uuid'?: string;
+  /** Root location used to resolve manifest and data-file paths. */
+  readonly location: string;
+  /** Current snapshot identifier, or `-1` when the table has no snapshot. */
+  readonly 'current-snapshot-id'?: number;
+  /** Snapshot sequence number. */
+  readonly 'last-sequence-number'?: number;
+  /** Metadata update time in milliseconds since the Unix epoch. */
+  readonly 'last-updated-ms'?: number;
+  /** Current schema identifier. */
+  readonly 'current-schema-id'?: number;
+  /** Schemas declared by the table metadata. */
+  readonly schemas?: readonly IcebergSchema[];
+  /** Partition specifications declared by the table metadata. */
+  readonly 'partition-specs'?: readonly IcebergPartitionSpec[];
+  /** Default partition specification identifier. */
+  readonly 'default-spec-id'?: number;
+  /** Table snapshots. */
+  readonly snapshots?: readonly IcebergSnapshot[];
+  /** Named snapshot references such as `main`, branches, and tags. */
+  readonly refs?: Readonly<Record<string, IcebergSnapshotReference>>;
+  /** Table properties. */
+  readonly properties?: Readonly<Record<string, string>>;
+  /** Additional Iceberg metadata fields retained for forward compatibility. */
+  readonly [key: string]: unknown;
+};
+
+/** Named Iceberg branch or tag reference. */
+export type IcebergSnapshotReference = Readonly<Record<string, unknown>> & {
+  readonly 'snapshot-id': number;
+  readonly type?: 'branch' | 'tag' | string;
+};
+
+/** Iceberg schema metadata retained without imposing a schema-model dependency. */
+export type IcebergSchema = Readonly<Record<string, unknown>> & {
+  readonly 'schema-id'?: number;
+  readonly fields?: readonly Readonly<Record<string, unknown>>[];
+};
+
+/** Iceberg partition specification metadata. */
+export type IcebergPartitionSpec = Readonly<Record<string, unknown>> & {
+  readonly 'spec-id'?: number;
+  readonly fields?: readonly Readonly<Record<string, unknown>>[];
+};
+
+/** Iceberg snapshot metadata used to select a manifest list. */
+export type IcebergSnapshot = Readonly<Record<string, unknown>> & {
+  readonly 'snapshot-id': number;
+  readonly 'sequence-number'?: number;
+  readonly 'manifest-list'?: string;
+  readonly 'schema-id'?: number;
+  readonly summary?: Readonly<Record<string, string>>;
+};
+
+/** One data or delete manifest referenced by an Iceberg manifest list. */
+export type IcebergManifestFile = Readonly<Record<string, unknown>> & {
+  readonly manifest_path: string;
+  readonly manifest_length?: number;
+  readonly partition_spec_id?: number;
+  readonly content?: number | string;
+};
+
+/** One data or delete file entry decoded from an Iceberg manifest. */
+export type IcebergDataFile = Readonly<Record<string, unknown>> & {
+  readonly file_path: string;
+  readonly file_format: string;
+  readonly file_size_in_bytes?: number;
+  readonly record_count?: number;
+  readonly partition?: Readonly<Record<string, unknown>>;
+  readonly lower_bounds?: Readonly<Record<string, unknown>>;
+  readonly upper_bounds?: Readonly<Record<string, unknown>>;
+  readonly content?: number | string;
+  readonly referenced_data_file?: string;
+  readonly equality_ids?: readonly number[];
+  readonly sort_order_id?: number;
+  readonly data_sequence_number?: number;
+};
+
+/** Parquet data-file plan produced by the Iceberg manifest reader. */
+export type IcebergParquetFile = {
+  readonly data: string;
+  readonly fileSize?: number;
+  readonly recordCount?: number;
+  readonly partition?: Readonly<Record<string, unknown>>;
+  readonly lowerBounds?: Readonly<Record<string, unknown>>;
+  readonly upperBounds?: Readonly<Record<string, unknown>>;
+  /** Manifest path that contributed this file. */
+  readonly manifestPath?: string;
+  /** Partition specification identifier for this manifest. */
+  readonly partitionSpecId?: number;
+  /** Snapshot used to produce this plan. */
+  readonly snapshotId?: number;
+  /** Iceberg data sequence number when supplied by the manifest entry. */
+  readonly dataSequenceNumber?: number;
+  /** Schema identifier used by the snapshot that contributed this file. */
+  readonly schemaId?: number;
+};
+
+/** Planned Iceberg delete file retained for optional delete application during a scan. */
+export type IcebergDeleteFile = {
+  /** URL or path of the delete file. */
+  readonly data: string;
+  /** Iceberg delete-file format, commonly `avro` or `puffin`. */
+  readonly format: string;
+  /** Delete content kind, such as position or equality deletes. */
+  readonly content?: number | string;
+  /** Referenced data file for a position delete file. */
+  readonly referencedDataFile?: string;
+  /** Field IDs used by an equality delete file. */
+  readonly equalityFieldIds?: readonly number[];
+  /** File size from the manifest. */
+  readonly fileSize?: number;
+  /** Record count from the manifest. */
+  readonly recordCount?: number;
+  /** Partition values from the manifest. */
+  readonly partition?: Readonly<Record<string, unknown>>;
+  /** Manifest path that contributed this delete file. */
+  readonly manifestPath?: string;
+  /** Partition specification identifier for this manifest. */
+  readonly partitionSpecId?: number;
+  /** Snapshot used to produce this plan. */
+  readonly snapshotId?: number;
+  /** Schema identifier used by the snapshot that contributed this delete file. */
+  readonly schemaId?: number;
+  /** Iceberg data sequence number associated with this delete file. */
+  readonly dataSequenceNumber?: number;
+};
+
+/** Files selected from one Iceberg snapshot before delete application. */
+export type IcebergScanPlan = {
+  /** Active Parquet data files selected from data manifests. */
+  readonly dataFiles: readonly IcebergParquetFile[];
+  /** Delete files discovered from delete manifests. */
+  readonly deleteFiles: readonly IcebergDeleteFile[];
+  /** Snapshot identifier used to build the plan. */
+  readonly snapshotId?: number;
+  /** Named snapshot reference used to build this plan, when supplied. */
+  readonly snapshotRef?: string;
+};
+
+/** Axis-aligned geographic bounds in `[minX, minY, maxX, maxY]` order. */
+export type IcebergBoundingBox = readonly [number, number, number, number];
+
+/** Conservative spatial filter used for Iceberg file-level pruning. */
+export type IcebergSpatialFilter = {
+  /** Top-level geometry column or Iceberg field name whose bounds are being queried. */
+  readonly column: string;
+  /** Query envelope in `[minX, minY, maxX, maxY]` order. */
+  readonly bbox: IcebergBoundingBox;
+};
+
+/** Options for constructing a read-only Iceberg table source. */
+export type IcebergTableSourceOptions = {
+  /** HTTP headers forwarded to metadata requests. */
+  readonly headers?: HeadersInit;
+};

package/src/index.ts

@@ -2,38 +2,105 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-export {Buffer} from './polyfills/buffer/install-buffer-polyfill';
-
 // import {ArrowTable, ArrowTableBatch} from '@loaders.gl/arrow';
 
 export {ParquetFormat} from './parquet-format';
 
-export {
-  ParquetJSONWorkerLoader,
-  ParquetJSONLoader,
-  GeoParquetWorkerLoader,
-  GeoParquetLoader,
-  // deprecated
-  ParquetJSONWorkerLoader as ParquetWorkerLoader,
-  ParquetJSONLoader as ParquetLoader
-} from './parquet-json-loader';
+export type {ParquetLoaderOptions, ParquetJSLoaderOptions} from './parquet-loader-options';
+export {ParquetLoader} from './parquet-loader-types';
+export {GeoParquetLoader} from './geoparquet-loader';
+export {ParquetJSLoader} from './parquet-js-loader-types';
 
+export {ParquetSourceLoader} from './parquet-source-loader-types';
+export type {
+  ParquetDeferredPageFilter,
+  ParquetEncodedColumnChunk,
+  ParquetEncodedPage,
+  ParquetEncodedPageBatch,
+  ParquetEncodedPageReadOptions,
+  ParquetEncodedPageSection,
+  ParquetPageCompressionState
+} from './parquet-encoded-page-types';
+export type {
+  ParquetBatch,
+  ParquetBatchMetadata,
+  ParquetBatchProvenance,
+  ParquetBoundingBox,
+  ParquetColumnChunkMetadata,
+  ParquetColumnChunkStatistics,
+  ParquetColumnChunkSizeStatistics,
+  ParquetGeospatialBoundingBox,
+  ParquetGeospatialStatistics,
+  ParquetDatasetBatch,
+  ParquetDatasetBatchProvenance,
+  ParquetDatasetBoundingBox,
+  ParquetDatasetExplain,
+  ParquetDatasetFile,
+  ParquetDatasetFileCollection,
+  ParquetDatasetFileScanPlan,
+  ParquetDatasetFileProvider,
+  ParquetDatasetFileQuery,
+  ParquetDatasetFiles,
+  ParquetDatasetPartitionValue,
+  ParquetDatasetReadOptions,
+  ParquetDatasetSourceOptions,
+  ParquetDatasetTelemetry,
+  ParquetMetadataRequestOptions,
+  ParquetObjectVersion,
+  ParquetPageScanPlan,
+  ParquetComparisonPredicate,
+  ParquetInPredicate,
+  ParquetLogicalPredicate,
+  ParquetNotPredicate,
+  ParquetNullPredicate,
+  ParquetPredicate,
+  ParquetPredicateProperty,
+  ParquetPredicateValue,
+  ParquetRangeRequestOptions,
+  ParquetReadOptions,
+  ParquetRowGroupMetadata,
+  ParquetSortingColumn,
+  ParquetSourceBatch,
+  ParquetSourceLoaderOptions,
+  ParquetSourceMetadata,
+  ParquetSourceReadOptions,
+  ParquetSourceExplain,
+  ParquetTelemetry,
+  ParquetTelemetryEvent
+} from './parquet-source-types';
 export {
-  ParquetJSONWriter as _ParquetJSONWriter,
-  // deprecated
-  ParquetJSONWriter as ParquetWriter
-} from './parquet-json-writer';
+  PARQUET_TABLE_QUERY_CAPABILITIES,
+  PARQUET_SOURCE_CAPABILITIES,
+  type ParquetSourceCapabilities
+} from './parquet-source-capabilities';
 
-// EXPERIMENTAL - expose Parquet WASM loaders/writer
+export {ParquetWriter} from './parquet-writer';
+export type {
+  ParquetJSWriterEncoding,
+  ParquetJSWriterOptions,
+  ParquetSortingColumnOption,
+  ParquetWriterEncryptionOptions,
+  ParquetWriterFooterSignatureOptions
+} from './parquet-js-writer';
+export {ParquetJSWriter} from './parquet-js-writer';
 
-export type {ParquetArrowLoaderOptions} from './parquet-arrow-loader';
-export {ParquetArrowLoader, ParquetArrowWorkerLoader} from './parquet-arrow-loader';
-export {ParquetArrowWriter} from './parquet-arrow-writer';
-
-// Experimental TypeScript-backed Parquet parser. The existing ParquetLoader aliases retain
-// their current behavior for 4.5 compatibility.
-export type {ParquetJSLoaderOptions} from './parquet-js-loader';
-export {ParquetJSLoader} from './parquet-js-loader';
+export {
+  decodeParquetColumnIndex,
+  decodeParquetPageStatisticsValue,
+  canUseParquetPageIndexForColumn,
+  type ParquetPageStatistics
+} from './lib/parquet-page-index';
+export {
+  createParquetModuleAad,
+  decryptParquetModule,
+  encryptParquetModule,
+  createParquetFooterSignature,
+  readParquetEncryptedModule,
+  verifyParquetFooterSignature,
+  type ParquetDecryptModuleOptions,
+  type ParquetEncryptionAlgorithm,
+  type ParquetKeyRetriever
+} from './lib/parquet-encryption';
 
 // EXPERIMENTAL - expose the internal parquetjs API
 
@@ -48,5 +115,17 @@ export {
   convertParquetSchema as convertParquetToArrowSchema
 } from './lib/arrow/convert-schema-from-parquet';
 
-// Experimental
-export {BufferPolyfill, installBufferPolyfill} from './polyfills/buffer/index';
+export {
+  checkParquetSplitBlockBloomFilter,
+  decodeParquetSplitBlockBloomFilter,
+  encodeParquetBloomFilterValue,
+  encodeParquetSplitBlockBloomFilter,
+  hashParquetBloomFilterValue,
+  insertParquetSplitBlockBloomFilter,
+  type ParquetBloomFilterPhysicalType,
+  type ParquetSplitBlockBloomFilter
+} from './lib/parquet-bloom-filter';
+export {
+  getParquetBloomFilterProbes,
+  type ParquetBloomFilterProbe
+} from './lib/parquet-bloom-filter-planner';

package/src/lib/arrow/convert-columns-to-row-group.ts

@@ -0,0 +1,3 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors

package/src/lib/arrow/convert-schema-from-parquet.ts

@@ -5,25 +5,28 @@
 import {Schema, Field, DataType} from '@loaders.gl/schema';
 
 import type {ParquetSchema} from '../../parquetjs/schema/schema';
-import type {FieldDefinition, ParquetField, ParquetType} from '../../parquetjs/schema/declare';
+import type {FieldDefinition, ParquetType, SchemaDefinition} from '../../parquetjs/schema/declare';
 import {FileMetaData} from '../../parquetjs/parquet-thrift';
 
 export const PARQUET_TYPE_MAPPING: {[type in ParquetType]: DataType} = {
   BOOLEAN: 'bool',
   INT32: 'int32',
-  INT64: 'float64',
+  INT64: 'int64',
   INT96: 'float64',
   FLOAT: 'float32',
   DOUBLE: 'float64',
   BYTE_ARRAY: 'binary',
   FIXED_LEN_BYTE_ARRAY: 'binary',
   UTF8: 'utf8',
-  DATE: 'int32',
-  TIME_MILLIS: 'int64',
-  TIME_MICROS: 'int64',
-  TIMESTAMP_MILLIS: 'int64',
-  TIMESTAMP_MICROS: 'int64',
-  UINT_8: 'int32',
+  ENUM: 'utf8',
+  DATE: 'date-day',
+  TIME_MILLIS: 'time-millisecond',
+  TIME_MICROS: 'time-microsecond',
+  TIME_NANOS: 'time-nanosecond',
+  TIMESTAMP_MILLIS: 'timestamp-millisecond',
+  TIMESTAMP_MICROS: 'timestamp-microsecond',
+  TIMESTAMP_NANOS: 'timestamp-nanosecond',
+  UINT_8: 'uint8',
   UINT_16: 'uint16',
   UINT_32: 'uint32',
   UINT_64: 'uint64',
@@ -31,21 +34,28 @@ export const PARQUET_TYPE_MAPPING: {[type in ParquetType]: DataType} = {
   INT_16: 'int16',
   INT_32: 'int32',
   INT_64: 'int64',
+  UUID: {type: 'fixed-size-binary', byteWidth: 16},
+  FLOAT16: 'float16',
+  UNKNOWN: 'null',
+  VARIANT: 'binary',
+  GEOMETRY: 'binary',
+  GEOGRAPHY: 'binary',
   JSON: 'binary',
   BSON: 'binary',
   // TODO check interal type
   INTERVAL: 'binary',
-  DECIMAL_INT32: 'float32',
-  DECIMAL_INT64: 'float64',
-  DECIMAL_BYTE_ARRAY: 'float64',
-  DECIMAL_FIXED_LEN_BYTE_ARRAY: 'float64'
+  DECIMAL_INT32: {type: 'decimal', bitWidth: 128, precision: 38, scale: 0},
+  DECIMAL_INT64: {type: 'decimal', bitWidth: 128, precision: 38, scale: 0},
+  DECIMAL_BYTE_ARRAY: {type: 'decimal', bitWidth: 128, precision: 38, scale: 0},
+  DECIMAL_FIXED_LEN_BYTE_ARRAY: {type: 'decimal', bitWidth: 128, precision: 38, scale: 0}
 };
 
 export function convertParquetSchema(
   parquetSchema: ParquetSchema,
-  parquetMetadata: FileMetaData | null
+  parquetMetadata: FileMetaData | null,
+  options?: {int96AsTimestamp?: boolean}
 ): Schema {
-  const fields = getFields(parquetSchema.schema);
+  const fields = getFields(parquetSchema.schema, options);
   const metadata = parquetMetadata && getSchemaMetadata(parquetMetadata);
 
   const schema: Schema = {
@@ -56,36 +66,187 @@ export function convertParquetSchema(
   return schema;
 }
 
-function getFields(schema: FieldDefinition): Field[] {
+function getFields(schema: SchemaDefinition, options?: {int96AsTimestamp?: boolean}): Field[] {
   const fields: Field[] = [];
 
   for (const name in schema) {
-    const field = schema[name];
-
-    if (field.fields) {
-      const children = getFields(field.fields);
-      fields.push({name, type: {type: 'struct', children}, nullable: field.optional});
-    } else {
-      const type = PARQUET_TYPE_MAPPING[field.type];
-      const metadata = getFieldMetadata(field);
-      const arrowField = {name, type, nullable: field.optional, metadata};
-      fields.push(arrowField);
-    }
+    fields.push(getField(name, schema[name], options));
   }
 
   return fields;
 }
 
-function getFieldMetadata(field: ParquetField): Record<string, string> | undefined {
+/** Converts one Parquet field, preserving repeated values as Arrow lists. */
+function getField(
+  name: string,
+  field: FieldDefinition,
+  options?: {int96AsTimestamp?: boolean}
+): Field {
+  const elementField: Field = {
+    name,
+    type: getFieldValueType(field, options),
+    nullable: Boolean(field.optional),
+    metadata: getFieldMetadata(field)
+  };
+
+  if (!field.repeated) {
+    return elementField;
+  }
+
+  return {
+    name,
+    type: {
+      type: 'list',
+      children: [{...elementField, name: 'element', nullable: false}]
+    },
+    nullable: Boolean(field.optional),
+    metadata: elementField.metadata
+  };
+}
+
+/** Converts a nested Parquet definition into its corresponding Arrow data type. */
+function getFieldValueType(
+  field: FieldDefinition,
+  options?: {int96AsTimestamp?: boolean}
+): DataType {
+  if (!field.fields) {
+    return getFieldType(field, options);
+  }
+
+  if (field.logicalType?.type === 'LIST') {
+    const element = field.fields.list?.fields?.element || field.fields.element;
+    if (!element) {
+      // Preserve unusual legacy LIST layouts as structs. Their group names and
+      // repetition levels are still available to the row-materialization path.
+      return {type: 'struct', children: getFields(field.fields, options)};
+    }
+    if (
+      (element.logicalType?.type === 'LIST' &&
+        (!isStandardListDefinition(element) || element.optional !== false)) ||
+      (element.logicalType?.type === 'MAP' &&
+        (!isStandardMapDefinition(element) || element.optional !== false))
+    ) {
+      // Preserve nested legacy wrappers. Arrow's high-level List/Map type
+      // cannot describe the historical wrapper shape without changing the
+      // object-row contract used by existing callers.
+      return {type: 'struct', children: getFields(field.fields, options)};
+    }
+    return {
+      type: 'list',
+      children: [
+        {
+          name: 'element',
+          type: getFieldValueType(element, options),
+          nullable: Boolean(element.optional)
+        }
+      ]
+    };
+  }
+
+  if (field.logicalType?.type === 'MAP') {
+    const entry = field.fields.key_value?.fields || field.fields;
+    const key = entry?.key;
+    const value = entry?.value;
+    if (!key || !value) {
+      // Preserve unusual legacy MAP layouts as structs rather than rejecting a
+      // file whose converted annotation does not follow the standard wrapper.
+      return {type: 'struct', children: getFields(field.fields, options)};
+    }
+    return {
+      type: 'map',
+      keysSorted: false,
+      children: [
+        {
+          name: 'entries',
+          type: {
+            type: 'struct',
+            children: [
+              {name: 'key', type: getFieldValueType(key, options), nullable: false},
+              {
+                name: 'value',
+                type: getFieldValueType(value, options),
+                nullable: Boolean(value.optional)
+              }
+            ]
+          },
+          nullable: false
+        }
+      ]
+    };
+  }
+
+  return {type: 'struct', children: getFields(field.fields, options)};
+}
+
+/** Returns whether a nested LIST follows the standard list/list/element wrapper. */
+function isStandardListDefinition(field: FieldDefinition): boolean {
+  return Boolean(field.fields?.list?.fields?.element);
+}
+
+/** Returns whether a nested MAP follows the standard map/key_value/key/value wrapper. */
+function isStandardMapDefinition(field: FieldDefinition): boolean {
+  return Boolean(field.fields?.key_value?.fields?.key && field.fields.key_value.fields.value);
+}
+
+/** Returns the exact serialized Arrow type for one decoded Parquet field. */
+function getFieldType(field: FieldDefinition, options?: {int96AsTimestamp?: boolean}): DataType {
+  if (field.type === 'INT96' && options?.int96AsTimestamp) {
+    return 'timestamp-nanosecond';
+  }
+  if (field.logicalType?.type === 'DECIMAL') {
+    const precision = field.precision ?? field.presision;
+    const scale = field.scale;
+    if (!precision || scale === undefined) {
+      throw new Error('Parquet DECIMAL logical type requires precision and scale');
+    }
+    if (precision > 76) {
+      throw new Error(`Parquet DECIMAL precision ${precision} exceeds Arrow Decimal256`);
+    }
+    return {type: 'decimal', bitWidth: precision <= 38 ? 128 : 256, precision, scale};
+  }
+  if (field.logicalType?.type === 'UUID') {
+    return {type: 'fixed-size-binary', byteWidth: field.typeLength || 16};
+  }
+  return PARQUET_TYPE_MAPPING[field.type!];
+}
+
+/** Returns defined physical field properties as Arrow-compatible string metadata. */
+function getFieldMetadata(field: FieldDefinition): Record<string, string> | undefined {
   let metadata: Record<string, string> | undefined;
 
+  if (
+    field.logicalType?.type === 'VARIANT' &&
+    field.logicalType.specificationVersion !== undefined
+  ) {
+    metadata = {
+      'parquet.variant.specification_version': String(field.logicalType.specificationVersion)
+    };
+  }
+
   for (const key in field) {
-    if (key !== 'name') {
-      let value = field[key] || '';
-      value = typeof field[key] !== 'string' ? JSON.stringify(field[key]) : field[key];
-      metadata = metadata || {};
-      metadata[key] = value;
+    const fieldValue = field[key];
+    if (
+      key === 'name' ||
+      key === 'fields' ||
+      (key === 'physicalType' && fieldValue === field.type) ||
+      (key === 'presision' && field.precision !== undefined) ||
+      fieldValue === undefined
+    ) {
+      continue;
+    }
+    const metadataValue =
+      typeof fieldValue === 'string'
+        ? fieldValue
+        : typeof fieldValue === 'boolean'
+          ? fieldValue
+            ? 'true'
+            : 'false'
+          : JSON.stringify(fieldValue);
+    if (metadataValue === undefined) {
+      continue;
     }
+    metadata ||= {};
+    metadata[key] = metadataValue;
   }
 
   return metadata;

package/src/lib/arrow/convert-schema-to-parquet.ts

@@ -18,19 +18,22 @@ import {
 export const PARQUET_TYPE_MAPPING: {[type in ParquetType]: DataType} = {
   BOOLEAN: 'bool',
   INT32: 'int32',
-  INT64: 'float64',
+  INT64: 'int64',
   INT96: 'float64',
   FLOAT: 'float32',
   DOUBLE: 'float64',
   BYTE_ARRAY: 'binary',
   FIXED_LEN_BYTE_ARRAY: 'binary',
   UTF8: 'utf8',
-  DATE: 'int32',
-  TIME_MILLIS: 'int64',
-  TIME_MICROS: 'int64',
-  TIMESTAMP_MILLIS: 'int64',
-  TIMESTAMP_MICROS: 'int64',
-  UINT_8: 'int32',
+  ENUM: 'utf8',
+  DATE: 'date-day',
+  TIME_MILLIS: 'time-millisecond',
+  TIME_MICROS: 'time-microsecond',
+  TIME_NANOS: 'time-nanosecond',
+  TIMESTAMP_MILLIS: 'timestamp-millisecond',
+  TIMESTAMP_MICROS: 'timestamp-microsecond',
+  TIMESTAMP_NANOS: 'timestamp-nanosecond',
+  UINT_8: 'uint8',
   UINT_16: 'uint16',
   UINT_32: 'uint32',
   UINT_64: 'uint64',
@@ -38,6 +41,12 @@ export const PARQUET_TYPE_MAPPING: {[type in ParquetType]: DataType} = {
   INT_16: 'int16',
   INT_32: 'int32',
   INT_64: 'int64',
+  UUID: {type: 'fixed-size-binary', byteWidth: 16},
+  FLOAT16: 'float16',
+  UNKNOWN: 'null',
+  VARIANT: 'binary',
+  GEOMETRY: 'binary',
+  GEOGRAPHY: 'binary',
   JSON: 'binary',
   BSON: 'binary',
   // TODO check interval type