@loaders.gl/parquet 3.4.6 → 4.0.0-alpha.10

package/dist/lib/arrow/convert-schema-to-parquet.js

@@ -2,43 +2,42 @@
 // loaders.gl, MIT license
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertToParquetSchema = exports.PARQUET_TYPE_MAPPING = void 0;
-const schema_1 = require("@loaders.gl/schema");
 exports.PARQUET_TYPE_MAPPING = {
-    BOOLEAN: schema_1.Bool,
-    INT32: schema_1.Int32,
-    INT64: schema_1.Float64,
-    INT96: schema_1.Float64,
-    FLOAT: schema_1.Float32,
-    DOUBLE: schema_1.Float64,
-    BYTE_ARRAY: schema_1.Binary,
-    FIXED_LEN_BYTE_ARRAY: schema_1.Binary,
-    UTF8: schema_1.Utf8,
-    DATE: schema_1.Int32,
-    TIME_MILLIS: schema_1.Int64,
-    TIME_MICROS: schema_1.Int64,
-    TIMESTAMP_MILLIS: schema_1.Int64,
-    TIMESTAMP_MICROS: schema_1.Int64,
-    UINT_8: schema_1.Int32,
-    UINT_16: schema_1.Uint16,
-    UINT_32: schema_1.Uint32,
-    UINT_64: schema_1.Uint64,
-    INT_8: schema_1.Int8,
-    INT_16: schema_1.Int16,
-    INT_32: schema_1.Int32,
-    INT_64: schema_1.Int64,
-    JSON: schema_1.Binary,
-    BSON: schema_1.Binary,
+    BOOLEAN: 'bool',
+    INT32: 'int32',
+    INT64: 'float64',
+    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',
+    UINT_16: 'uint16',
+    UINT_32: 'uint32',
+    UINT_64: 'uint64',
+    INT_8: 'int8',
+    INT_16: 'int16',
+    INT_32: 'int32',
+    INT_64: 'int64',
+    JSON: 'binary',
+    BSON: 'binary',
     // TODO check interval type
-    INTERVAL: schema_1.Binary,
-    DECIMAL_INT32: schema_1.Float32,
-    DECIMAL_INT64: schema_1.Float64,
-    DECIMAL_BYTE_ARRAY: schema_1.Float64,
-    DECIMAL_FIXED_LEN_BYTE_ARRAY: schema_1.Float64
+    INTERVAL: 'binary',
+    DECIMAL_INT32: 'float32',
+    DECIMAL_INT64: 'float64',
+    DECIMAL_BYTE_ARRAY: 'float64',
+    DECIMAL_FIXED_LEN_BYTE_ARRAY: 'float64'
 };
 function convertToParquetSchema(schema) {
     const fields = []; // getFields(schema.fields);
     // TODO add metadata if needed.
-    return new schema_1.Schema(fields);
+    return { fields, metadata: {} };
 }
 exports.convertToParquetSchema = convertToParquetSchema;
 // function getFields(schema: Field[]): Definition[] {

package/dist/lib/geo/decode-geo-metadata.js

@@ -5,7 +5,7 @@ exports.unpackGeoMetadata = exports.setGeoMetadata = exports.getGeoMetadata = vo
  * Reads the GeoMetadata object from the metadata
  * @note geoarrow / parquet schema is stringified into a single key-value pair in the parquet metadata */
 function getGeoMetadata(schema) {
-    const stringifiedGeoMetadata = schema.metadata.get('geo');
+    const stringifiedGeoMetadata = schema.metadata.geo;
     if (!stringifiedGeoMetadata) {
         return null;
     }
@@ -24,7 +24,7 @@ exports.getGeoMetadata = getGeoMetadata;
  */
 function setGeoMetadata(schema, geoMetadata) {
     const stringifiedGeoMetadata = JSON.stringify(geoMetadata);
-    schema.metadata.set('geo', stringifiedGeoMetadata);
+    schema.metadata.geo = stringifiedGeoMetadata;
 }
 exports.setGeoMetadata = setGeoMetadata;
 /**
@@ -39,18 +39,18 @@ function unpackGeoMetadata(schema) {
     // Store Parquet Schema Level Metadata
     const { version, primary_column, columns } = geoMetadata;
     if (version) {
-        schema.metadata.set('geo.version', version);
+        schema.metadata['geo.version'] = version;
     }
     if (primary_column) {
-        schema.metadata.set('geo.primary_column', primary_column);
+        schema.metadata['geo.primary_column'] = primary_column;
     }
     // store column names as comma separated list
-    schema.metadata.set('geo.columns', Object.keys(columns || {}).join(''));
+    schema.metadata['geo.columns'] = Object.keys(columns || {}).join('');
     for (const [columnName, columnMetadata] of Object.entries(columns || {})) {
         const field = schema.fields.find((field) => field.name === columnName);
         if (field) {
             if (field.name === primary_column) {
-                field.metadata.set('geo.primary_field', 'true');
+                setFieldMetadata(field, 'geo.primary_field', 'true');
             }
             unpackGeoFieldMetadata(field, columnMetadata);
         }
@@ -61,13 +61,17 @@ function unpackGeoFieldMetadata(field, columnMetadata) {
     for (const [key, value] of Object.entries(columnMetadata || {})) {
         switch (key) {
             case 'geometry_type':
-                field.metadata.set(`geo.${key}`, value.join(','));
+                setFieldMetadata(field, `geo.${key}`, value.join(','));
                 break;
             case 'bbox':
             case 'crs':
             case 'edges':
             default:
-                field.metadata.set(`geo.${key}`, typeof value === 'string' ? value : JSON.stringify(value));
+                setFieldMetadata(field, `geo.${key}`, typeof value === 'string' ? value : JSON.stringify(value));
         }
     }
 }
+function setFieldMetadata(field, key, value) {
+    field.metadata = field.metadata || {};
+    field.metadata[key] = value;
+}

package/dist/lib/parsers/parse-parquet-to-columns.d.ts

@@ -1,5 +1,5 @@
-import { ColumnarTableBatch } from '@loaders.gl/schema';
+import { ColumnarTable, ColumnarTableBatch } from '@loaders.gl/schema';
 import type { ParquetLoaderOptions } from '../../parquet-loader';
-export declare function parseParquetInColumns(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions): Promise<ColumnarTableBatch | null>;
+export declare function parseParquetInColumns(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions): Promise<ColumnarTable>;
 export declare function parseParquetFileInColumnarBatches(blob: Blob, options?: ParquetLoaderOptions): AsyncIterable<ColumnarTableBatch>;
 //# sourceMappingURL=parse-parquet-to-columns.d.ts.map

package/dist/lib/parsers/parse-parquet-to-columns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-parquet-to-columns.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-parquet-to-columns.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,kBAAkB,EAAS,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAO/D,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,sCAO/B;AAED,wBAAuB,iCAAiC,CACtD,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa,CAAC,kBAAkB,CAAC,CAWnC"}
+{"version":3,"file":"parse-parquet-to-columns.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-parquet-to-columns.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,aAAa,EAAE,kBAAkB,EAAS,MAAM,oBAAoB,CAAC;AAE7E,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAS/D,wBAAsB,qBAAqB,CACzC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,aAAa,CAAC,CAUxB;AAED,wBAAuB,iCAAiC,CACtD,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa,CAAC,kBAAkB,CAAC,CAWnC"}

package/dist/lib/parsers/parse-parquet-to-columns.js

@@ -5,14 +5,19 @@ exports.parseParquetFileInColumnarBatches = exports.parseParquetInColumns = void
 const loader_utils_1 = require("@loaders.gl/loader-utils");
 const parquet_reader_1 = require("../../parquetjs/parser/parquet-reader");
 const convert_schema_from_parquet_1 = require("../arrow/convert-schema-from-parquet");
-const convert_row_group_to_columns_1 = require("../arrow/convert-row-group-to-columns");
+const shred_1 = require("../../parquetjs/schema/shred");
+// import {convertParquetRowGroupToColumns} from '../arrow/convert-row-group-to-columns';
 const decode_geo_metadata_1 = require("../geo/decode-geo-metadata");
 async function parseParquetInColumns(arrayBuffer, options) {
     const blob = new Blob([arrayBuffer]);
     for await (const batch of parseParquetFileInColumnarBatches(blob, options)) {
-        return batch;
+        return {
+            shape: 'columnar-table',
+            schema: batch.schema,
+            data: batch.data
+        };
     }
-    return null;
+    throw new Error('empty table');
 }
 exports.parseParquetInColumns = parseParquetInColumns;
 async function* parseParquetFileInColumnarBatches(blob, options) {
@@ -20,16 +25,17 @@ async function* parseParquetFileInColumnarBatches(blob, options) {
     const reader = new parquet_reader_1.ParquetReader(file);
     const parquetSchema = await reader.getSchema();
     const parquetMetadata = await reader.getFileMetadata();
-    const schema = (0, convert_schema_from_parquet_1.convertSchemaFromParquet)(parquetSchema, parquetMetadata);
+    const schema = (0, convert_schema_from_parquet_1.convertParquetSchema)(parquetSchema, parquetMetadata);
     (0, decode_geo_metadata_1.unpackGeoMetadata)(schema);
     const rowGroups = reader.rowGroupIterator(options?.parquet);
     for await (const rowGroup of rowGroups) {
-        yield convertRowGroupToTableBatch(schema, rowGroup);
+        yield convertRowGroupToTableBatch(parquetSchema, rowGroup, schema);
     }
 }
 exports.parseParquetFileInColumnarBatches = parseParquetFileInColumnarBatches;
-function convertRowGroupToTableBatch(schema, rowGroup) {
-    const data = (0, convert_row_group_to_columns_1.convertParquetRowGroupToColumns)(schema, rowGroup);
+function convertRowGroupToTableBatch(parquetSchema, rowGroup, schema) {
+    // const data = convertParquetRowGroupToColumns(schema, rowGroup);
+    const data = (0, shred_1.materializeColumns)(parquetSchema, rowGroup);
     return {
         shape: 'columnar-table',
         batchType: 'data',

package/dist/lib/parsers/parse-parquet-to-rows.d.ts

@@ -1,4 +1,5 @@
+import { ObjectRowTable, ObjectRowTableBatch } from '@loaders.gl/schema';
 import type { ParquetLoaderOptions } from '../../parquet-loader';
-export declare function parseParquet(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions): Promise<import("../../parquetjs/schema/declare").ParquetRecord[] | null>;
-export declare function parseParquetFileInBatches(blob: Blob, options?: ParquetLoaderOptions): AsyncGenerator<import("../../parquetjs/schema/declare").ParquetRecord[], void, unknown>;
+export declare function parseParquet(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions): Promise<ObjectRowTable>;
+export declare function parseParquetFileInBatches(blob: Blob, options?: ParquetLoaderOptions): AsyncIterable<ObjectRowTableBatch>;
 //# sourceMappingURL=parse-parquet-to-rows.d.ts.map

package/dist/lib/parsers/parse-parquet-to-rows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-parquet-to-rows.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-parquet-to-rows.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAG/D,wBAAsB,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,oBAAoB,4EAM1F;AAED,wBAAuB,yBAAyB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,oBAAoB,2FAO1F"}
+{"version":3,"file":"parse-parquet-to-rows.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-parquet-to-rows.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAI/D,wBAAsB,YAAY,CAChC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,cAAc,CAAC,CAgBzB;AAED,wBAAuB,yBAAyB,CAC9C,IAAI,EAAE,IAAI,EACV,OAAO,CAAC,EAAE,oBAAoB,GAC7B,aAAa,CAAC,mBAAmB,CAAC,CAYpC"}

package/dist/lib/parsers/parse-parquet-to-rows.js

@@ -7,10 +7,18 @@ const loader_utils_1 = require("@loaders.gl/loader-utils");
 const parquet_reader_1 = require("../../parquetjs/parser/parquet-reader");
 async function parseParquet(arrayBuffer, options) {
     const blob = new Blob([arrayBuffer]);
+    const rows = [];
     for await (const batch of parseParquetFileInBatches(blob, options)) {
-        return batch;
+        // we have only one input batch so return
+        for (const row of batch.data) {
+            rows.push(row);
+        }
     }
-    return null;
+    return {
+        shape: 'object-row-table',
+        // TODO - spread can fail for very large number of batches
+        data: rows
+    };
 }
 exports.parseParquet = parseParquet;
 async function* parseParquetFileInBatches(blob, options) {
@@ -18,23 +26,12 @@ async function* parseParquetFileInBatches(blob, options) {
     const reader = new parquet_reader_1.ParquetReader(file);
     const rowBatches = reader.rowBatchIterator(options?.parquet);
     for await (const rows of rowBatches) {
-        yield rows;
+        yield {
+            shape: 'object-row-table',
+            data: rows,
+            batchType: 'data',
+            length: rows.length
+        };
     }
 }
 exports.parseParquetFileInBatches = parseParquetFileInBatches;
-// export async function* parseParquetFileInColumnarBatches(blob: Blob, options?: {columnList?: string[][]}): AsyncIterable<ColumnarTableBatch> {
-//   const rowGroupReader = new ParquetRowGroupReader({data: blob, columnList: options?.columnList});
-//   try {
-//     for await (const rowGroup of rowGroupReader) {
-//       yield convertRowGroupToTableBatch(rowGroup);
-//     }
-//   } finally {
-//     await rowGroupReader.close();
-//   }
-// }
-// function convertRowGroupToTableBatch(rowGroup): ColumnarTableBatch {
-//   // @ts-expect-error
-//   return {
-//     data: rowGroup
-//   };
-// }

package/dist/lib/wasm/parse-parquet-wasm.d.ts

@@ -1,10 +1,10 @@
 import type { LoaderOptions } from '@loaders.gl/loader-utils';
-import { Table } from 'apache-arrow';
-export type ParquetLoaderOptions = LoaderOptions & {
+import { Table as ArrowTable } from 'apache-arrow';
+export type ParquetWasmLoaderOptions = LoaderOptions & {
     parquet?: {
         type?: 'arrow-table';
         wasmUrl?: string;
     };
 };
-export declare function parseParquet(arrayBuffer: ArrayBuffer, options?: ParquetLoaderOptions): Promise<Table>;
+export declare function parseParquetWasm(arrayBuffer: ArrayBuffer, options?: ParquetWasmLoaderOptions): Promise<ArrowTable>;
 //# sourceMappingURL=parse-parquet-wasm.d.ts.map

package/dist/lib/wasm/parse-parquet-wasm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-parquet-wasm.d.ts","sourceRoot":"","sources":["../../../src/lib/wasm/parse-parquet-wasm.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAC,KAAK,EAA0B,MAAM,cAAc,CAAC;AAG5D,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IACjD,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,aAAa,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,CAAC;AAEF,wBAAsB,YAAY,CAChC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,GAC7B,OAAO,CAAC,KAAK,CAAC,CAYhB"}
+{"version":3,"file":"parse-parquet-wasm.d.ts","sourceRoot":"","sources":["../../../src/lib/wasm/parse-parquet-wasm.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAC,KAAK,IAAI,UAAU,EAA0B,MAAM,cAAc,CAAC;AAG1E,MAAM,MAAM,wBAAwB,GAAG,aAAa,GAAG;IACrD,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,aAAa,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH,CAAC;AAEF,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,UAAU,CAAC,CAYrB"}

package/dist/lib/wasm/parse-parquet-wasm.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseParquet = void 0;
+exports.parseParquetWasm = void 0;
 const apache_arrow_1 = require("apache-arrow");
 const load_wasm_node_1 = require("./load-wasm/load-wasm-node");
-async function parseParquet(arrayBuffer, options) {
+async function parseParquetWasm(arrayBuffer, options) {
     const wasmUrl = options?.parquet?.wasmUrl;
     const wasm = await (0, load_wasm_node_1.loadWasm)(wasmUrl);
     const arr = new Uint8Array(arrayBuffer);
@@ -12,7 +12,7 @@ async function parseParquet(arrayBuffer, options) {
     const arrowTable = tableFromIPC(arrowIPCBuffer);
     return arrowTable;
 }
-exports.parseParquet = parseParquet;
+exports.parseParquetWasm = parseParquetWasm;
 /**
  * Deserialize the IPC format into a {@link Table}. This function is a
  * convenience wrapper for {@link RecordBatchReader}. Opposite of {@link tableToIPC}.

package/dist/parquet-loader.d.ts

@@ -1,4 +1,5 @@
 import type { Loader, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { ObjectRowTable, ObjectRowTableBatch, ColumnarTable, ColumnarTableBatch } from '@loaders.gl/schema';
 export type ParquetLoaderOptions = LoaderOptions & {
     parquet?: {
         type?: 'object-row-table';
@@ -8,18 +9,6 @@ export type ParquetLoaderOptions = LoaderOptions & {
     };
 };
 /** ParquetJS table loader */
-export declare const ParquetLoader: {
-    name: string;
-    id: string;
-    module: string;
-    version: any;
-    worker: boolean;
-    category: string;
-    extensions: string[];
-    mimeTypes: string[];
-    binary: boolean;
-    tests: string[];
-    options: ParquetLoaderOptions;
-};
-export declare const _typecheckParquetLoader: Loader;
+export declare const ParquetLoader: Loader<ObjectRowTable, ObjectRowTableBatch, ParquetLoaderOptions>;
+export declare const ParqueColumnnartLoader: Loader<ColumnarTable, ColumnarTableBatch, ParquetLoaderOptions>;
 //# sourceMappingURL=parquet-loader.d.ts.map

package/dist/parquet-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parquet-loader.d.ts","sourceRoot":"","sources":["../src/parquet-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAMpE,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IACjD,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,kBAAkB,CAAC;QAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC;QACnC,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,CAAC;CACH,CAAC;AAWF,6BAA6B;AAC7B,eAAO,MAAM,aAAa;;;;;;;;;;;;CAYzB,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MAAsB,CAAC"}
+{"version":3,"file":"parquet-loader.d.ts","sourceRoot":"","sources":["../src/parquet-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AACpE,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAM5B,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IACjD,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,kBAAkB,CAAC;QAC1B,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,EAAE,CAAC;QACnC,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,CAAC;CACH,CAAC;AAWF,6BAA6B;AAC7B,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,cAAc,EAAE,mBAAmB,EAAE,oBAAoB,CAY3F,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,MAAM,CACzC,aAAa,EACb,kBAAkB,EAClB,oBAAoB,CAarB,CAAC"}

package/dist/parquet-loader.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckParquetLoader = exports.ParquetLoader = void 0;
+exports.ParqueColumnnartLoader = exports.ParquetLoader = void 0;
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
@@ -26,4 +26,16 @@ exports.ParquetLoader = {
     tests: ['PAR1', 'PARE'],
     options: DEFAULT_PARQUET_LOADER_OPTIONS
 };
-exports._typecheckParquetLoader = exports.ParquetLoader;
+exports.ParqueColumnnartLoader = {
+    name: 'Apache Parquet',
+    id: 'parquet',
+    module: 'parquet',
+    version: VERSION,
+    worker: true,
+    category: 'table',
+    extensions: ['parquet'],
+    mimeTypes: ['application/octet-stream'],
+    binary: true,
+    tests: ['PAR1', 'PARE'],
+    options: DEFAULT_PARQUET_LOADER_OPTIONS
+};