@gscdump/engine 3.1.0 → 3.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Harlan Wilton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/THIRD-PARTY-LICENSES.md

@@ -35,11 +35,11 @@ Repository: https://github.com/101arrowz/fzstd
 
 ---------------------------------------
 
-## hyparquet, hyparquet, hyparquet-compressors, hyparquet-writer, icebird, squirreling
+## hyparquet, hyparquet, hyparquet, hyparquet-compressors, hyparquet-writer, icebird, squirreling
 
 License: MIT
 By: Hyperparam
-Repositories: https://github.com/hyparam/hyparquet, https://github.com/hyparam/hyparquet, https://github.com/hyparam/hyparquet-compressors, https://github.com/hyparam/hyparquet-writer, https://github.com/hyparam/icebird, https://github.com/hyparam/squirreling
+Repositories: https://github.com/hyparam/hyparquet, https://github.com/hyparam/hyparquet, https://github.com/hyparam/hyparquet, https://github.com/hyparam/hyparquet-compressors, https://github.com/hyparam/hyparquet-writer, https://github.com/hyparam/icebird, https://github.com/hyparam/squirreling
 
 > The MIT License (MIT)
 > 

package/dist/adapters/hyparquet.d.mts

@@ -1,5 +1,5 @@
-import { ParquetQueryFilter } from "../node_modules/.pnpm/hyparquet@1.28.2/node_modules/hyparquet/types/index.mjs";
-import "../node_modules/.pnpm/hyparquet@1.28.2/node_modules/hyparquet/types/node.mjs";
+import { ParquetQueryFilter } from "../node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/types/index.mjs";
+import "../node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/types/node.mjs";
 import { CodecCtx, DataSource, ParquetCodec, Row, TableName } from "../storage.mjs";
 import { ColumnDef } from "../schema.mjs";
 declare function encodeRowsToParquet(table: TableName, rows: readonly Row[]): Uint8Array;

package/dist/adapters/hyparquet.mjs

@@ -1,7 +1,7 @@
 import { TABLE_METADATA } from "../drizzle-schema.mjs";
 import { SCHEMAS } from "../schema.mjs";
-import { parquetReadObjects } from "../node_modules/.pnpm/hyparquet@1.28.2/node_modules/hyparquet/src/read.mjs";
-import "../node_modules/.pnpm/hyparquet@1.28.2/node_modules/hyparquet/src/node.mjs";
+import { parquetReadObjects } from "../node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/read.mjs";
+import "../node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/node.mjs";
 import { ByteWriter } from "../node_modules/.pnpm/hyparquet-writer@0.16.6_patch_hash_549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a/node_modules/hyparquet-writer/src/bytewriter.mjs";
 import { parquetWriteRows } from "../node_modules/.pnpm/hyparquet-writer@0.16.6_patch_hash_549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a/node_modules/hyparquet-writer/src/write-rows.mjs";
 import "../node_modules/.pnpm/hyparquet-writer@0.16.6_patch_hash_549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a/node_modules/hyparquet-writer/src/node.mjs";

package/dist/iceberg/catalog.d.mts

@@ -1,7 +1,7 @@
 import { EngineError } from "../errors.mjs";
 import { IcebergTableName, PartitionKeyEncoding } from "./schema.mjs";
-import { icebergCreateTable } from "../node_modules/.pnpm/icebird@0.8.22_patch_hash_4fa7fd5702c4ce432fb2902c6abe07cc55565e87f6375b96ece63a10999712e6/node_modules/icebird/types/write/write.mjs";
-import "../node_modules/.pnpm/icebird@0.8.22_patch_hash_4fa7fd5702c4ce432fb2902c6abe07cc55565e87f6375b96ece63a10999712e6/node_modules/icebird/types/index.mjs";
+import { icebergCreateTable } from "../node_modules/.pnpm/icebird@0.8.26_patch_hash_75eacba5b0363ee2a40baa0ef77c7fb20d06389025186ca95b514a927cad0244/node_modules/icebird/types/write/write.mjs";
+import "../node_modules/.pnpm/icebird@0.8.26_patch_hash_75eacba5b0363ee2a40baa0ef77c7fb20d06389025186ca95b514a927cad0244/node_modules/icebird/types/index.mjs";
 import { Result } from "gscdump/result";
 import { CommitRetryOptions, ConnectIcebergOptions, IcebergCatalogConfig, IcebergConnection, IcebergListedDataFile, QueryProfiler } from "@gscdump/lakehouse";
 type IcebirdCreateTableOptions = Parameters<typeof icebergCreateTable>[0];

package/dist/iceberg/catalog.mjs

@@ -2,8 +2,8 @@ import { engineErrors } from "../errors.mjs";
 import { TABLE_METADATA } from "../drizzle-schema.mjs";
 import "../schema.mjs";
 import { DEFAULT_PARTITION_KEY_ENCODING, ICEBERG_PARTITION_SPEC, ICEBERG_TABLES, icebergSchemasFor } from "./schema.mjs";
-import { icebergCreateTable } from "../node_modules/.pnpm/icebird@0.8.22_patch_hash_4fa7fd5702c4ce432fb2902c6abe07cc55565e87f6375b96ece63a10999712e6/node_modules/icebird/src/write/write.mjs";
-import "../node_modules/.pnpm/icebird@0.8.22_patch_hash_4fa7fd5702c4ce432fb2902c6abe07cc55565e87f6375b96ece63a10999712e6/node_modules/icebird/src/index.mjs";
+import { icebergCreateTable } from "../node_modules/.pnpm/icebird@0.8.26_patch_hash_75eacba5b0363ee2a40baa0ef77c7fb20d06389025186ca95b514a927cad0244/node_modules/icebird/src/write/write.mjs";
+import "../node_modules/.pnpm/icebird@0.8.26_patch_hash_75eacba5b0363ee2a40baa0ef77c7fb20d06389025186ca95b514a927cad0244/node_modules/icebird/src/index.mjs";
 import { err, ok } from "gscdump/result";
 import { ICEBERG_TYPE_MAP, connectIcebergCatalog, dropIcebergTables, resolveIcebergDataFiles } from "@gscdump/lakehouse";
 import { icebergAppendRetrying } from "@gscdump/lakehouse/unsafe-raw";

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/assemble.mjs

@@ -0,0 +1,3 @@
+import "./schema.mjs";
+import "./variant.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/bloom.mjs

@@ -0,0 +1,14 @@
+import "./thrift.mjs";
+import "./xxhash.mjs";
+new TextEncoder();
+new Uint32Array([
+	1203114875,
+	1150766481,
+	2284105051,
+	2729912477,
+	1884591559,
+	770785867,
+	2667333959,
+	1550580529
+]);
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/column.mjs

@@ -0,0 +1,8 @@
+import "./constants.mjs";
+import "./convert.mjs";
+import "./schema.mjs";
+import "./thrift.mjs";
+import "./assemble.mjs";
+import "./plain.mjs";
+import "./datapage.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/convert.mjs

@@ -0,0 +1,3 @@
+import "./wkb.mjs";
+new TextDecoder();
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/datapage.mjs

@@ -0,0 +1,6 @@
+import "./schema.mjs";
+import "./delta.mjs";
+import "./encoding.mjs";
+import "./plain.mjs";
+import "./snappy.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/delta.mjs

@@ -0,0 +1,2 @@
+import "./thrift.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/encoding.mjs

@@ -0,0 +1,2 @@
+import "./thrift.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/filter.mjs

@@ -0,0 +1,4 @@
+import "./bloom.mjs";
+import "./utils.mjs";
+new TextEncoder();
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/index.mjs

@@ -0,0 +1,8 @@
+import "./metadata.mjs";
+import "./indexes.mjs";
+import "./utils.mjs";
+import "./snappy.mjs";
+import "./scan.mjs";
+import "./read.mjs";
+import "./query.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/indexes.mjs

@@ -0,0 +1,5 @@
+import "./constants.mjs";
+import "./convert.mjs";
+import "./thrift.mjs";
+import "./metadata.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/metadata.mjs

@@ -0,0 +1,7 @@
+import "./constants.mjs";
+import "./convert.mjs";
+import "./schema.mjs";
+import "./thrift.mjs";
+import "./geoparquet.mjs";
+new TextDecoder();
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/node.mjs

@@ -0,0 +1,2 @@
+import "./index.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/plan.mjs

@@ -0,0 +1,6 @@
+import "./schema.mjs";
+import "./metadata.mjs";
+import "./indexes.mjs";
+import "./bloom.mjs";
+import "./filter.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/read.mjs

@@ -0,0 +1,7 @@
+import "./metadata.mjs";
+import "./utils.mjs";
+import "./filter.mjs";
+import "./plan.mjs";
+import "./rowgroup.mjs";
+import "./scan.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/rowgroup.mjs

@@ -0,0 +1,7 @@
+import "./convert.mjs";
+import "./schema.mjs";
+import "./indexes.mjs";
+import "./utils.mjs";
+import "./assemble.mjs";
+import "./column.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/scan.mjs

@@ -0,0 +1,6 @@
+import "./metadata.mjs";
+import "./utils.mjs";
+import "./filter.mjs";
+import "./plan.mjs";
+import "./rowgroup.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/types.d.mts

@@ -0,0 +1,9 @@
+/**
+ * File-like object that can read slices of a file asynchronously.
+ */
+interface AsyncBuffer {
+  byteLength: number;
+  slice(start: number, end?: number): Awaitable<ArrayBuffer>;
+}
+type Awaitable<T> = T | Promise<T>;
+export { AsyncBuffer, Awaitable };

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/utils.mjs

@@ -0,0 +1,2 @@
+import "./metadata.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/src/variant.mjs

@@ -0,0 +1,3 @@
+import "./convert.mjs";
+new TextDecoder();
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/types/index.d.mts

@@ -0,0 +1,10 @@
+import { AsyncBuffer as AsyncBuffer$1 } from "../src/types.mjs";
+import "./indexes.mjs";
+import "./metadata.mjs";
+import "./read.mjs";
+import "./scan.mjs";
+import "./query.mjs";
+import "./snappy.mjs";
+import "./utils.mjs";
+type AsyncBuffer = AsyncBuffer$1;
+export { AsyncBuffer };

package/dist/node_modules/.pnpm/hyparquet@1.29.1/node_modules/hyparquet/types/node.d.mts

@@ -0,0 +1,3 @@
+import "../src/types.mjs";
+import { AsyncBuffer } from "./index.mjs";
+export { AsyncBuffer };

package/dist/node_modules/.pnpm/{hyparquet@1.28.2 → hyparquet@1.29.2}/node_modules/hyparquet/src/index.mjs

@@ -2,6 +2,7 @@ import "./metadata.mjs";
 import "./indexes.mjs";
 import "./utils.mjs";
 import "./snappy.mjs";
+import "./scan.mjs";
 import { parquetReadObjects } from "./read.mjs";
 import "./query.mjs";
 export { parquetReadObjects };

package/dist/node_modules/.pnpm/{hyparquet@1.28.2 → hyparquet@1.29.2}/node_modules/hyparquet/src/plan.mjs

@@ -4,123 +4,151 @@ import { readColumnIndex, readOffsetIndex } from "./indexes.mjs";
 import { bloomEligibleColumns, readBloomFilter } from "./bloom.mjs";
 import { canSkipRowGroup, filterPageRanges, pathsNeededForFilter } from "./filter.mjs";
 const runLimit = 1 << 21;
-function parquetPlan({ metadata, rowStart = 0, rowEnd = Infinity, columns, filter, filterStrict = true, useOffsetIndex = false, bloomFiltersByGroup, schemaElements, pageRangesByGroup, pageLocationsByGroup }) {
+function parquetPlan(options) {
+	const { metadata, rowStart = 0, columns, useOffsetIndex = false } = options;
 	if (!metadata) throw new Error("parquetPlan requires metadata");
 	const groups = [];
 	const fetches = [];
 	const indexes = [];
+	const scanPlan = parquetPlanGroups(options);
+	for (const group of scanPlan.groups) {
+		const groupPlan = parquetPlanGroup({
+			...group,
+			columns,
+			useOffsetIndex
+		});
+		groups.push(...groupPlan.groups);
+		fetches.push(...groupPlan.fetches);
+		indexes.push(...groupPlan.indexes);
+	}
+	fetches.push(...indexes);
+	return {
+		metadata,
+		rowStart,
+		rowEnd: scanPlan.rowEnd,
+		columns,
+		fetches,
+		groups
+	};
+}
+function parquetPlanGroups({ metadata, rowStart = 0, rowEnd = Infinity, columns, filter, filterStrict = true, bloomFiltersByGroup, schemaElements, pageRangesByGroup, pageLocationsByGroup }) {
+	if (!metadata) throw new Error("parquetPlan requires metadata");
 	const schemaTree = parquetSchema(metadata);
 	const physicalColumns = getPhysicalColumns(schemaTree);
 	const elementsByPath = filter ? {
 		...physicalSchemaElements(schemaTree),
 		...schemaElements
 	} : schemaElements;
+	const groups = [];
 	let groupStart = 0;
-	let rgIdx = 0;
-	for (const rowGroup of metadata.row_groups) {
+	for (let groupIndex = 0; groupIndex < metadata.row_groups.length; groupIndex++) {
+		const rowGroup = metadata.row_groups[groupIndex];
 		const groupRows = Number(rowGroup.num_rows);
 		const groupEnd = groupStart + groupRows;
-		const bloomFilters = bloomFiltersByGroup?.[rgIdx];
 		if (groupRows > 0 && groupEnd > rowStart && groupStart < rowEnd && !canSkipRowGroup({
 			rowGroup,
 			physicalColumns,
 			filter,
 			strict: filterStrict,
-			bloomFilters,
+			bloomFilters: bloomFiltersByGroup?.[groupIndex],
 			schemaElements: elementsByPath
 		})) {
 			const selectStart = Math.max(rowStart - groupStart, 0);
 			const selectEnd = Math.min(rowEnd - groupStart, groupRows);
-			const pageRanges = pageRangesByGroup?.[rgIdx];
-			const pageLocations = pageLocationsByGroup?.[rgIdx];
-			let subranges = pageRanges ? pageRanges.map(([start, end]) => {
+			const pageRanges = pageRangesByGroup?.[groupIndex];
+			const pageLocations = pageLocationsByGroup?.[groupIndex];
+			let ranges = pageRanges ? pageRanges.map(([start, end]) => {
 				return [Math.max(start, selectStart), Math.min(end, selectEnd)];
 			}).filter(([start, end]) => start < end) : [[selectStart, selectEnd]];
-			if (subranges.length > 1) {
-				if (!rowGroup.columns.every((chunk) => {
-					const columnName = chunk.meta_data?.path_in_schema[0];
-					const columnPath = chunk.meta_data?.path_in_schema.join(".");
-					if (columns && columnName && !columns.includes(columnName)) return true;
-					return !!(chunk.offset_index_offset && chunk.offset_index_length) || !!(columnPath && pageLocations?.[columnPath]);
-				})) subranges = [[subranges[0][0], subranges[subranges.length - 1][1]]];
-				else subranges = coalesceOverlappingPageRanges(subranges, rowGroup, columns, pageLocations);
+			if (ranges.length > 1) ranges = rowGroup.columns.every((chunk) => {
+				const columnName = chunk.meta_data?.path_in_schema[0];
+				const columnPath = chunk.meta_data?.path_in_schema.join(".");
+				if (columns && columnName && !columns.includes(columnName)) return true;
+				return !!(chunk.offset_index_offset && chunk.offset_index_length) || !!(columnPath && pageLocations?.[columnPath]);
+			}) ? coalesceOverlappingPageRanges(ranges, rowGroup, columns, pageLocations) : [[ranges[0][0], ranges[ranges.length - 1][1]]];
+			if (ranges.length) groups.push({
+				rowGroup,
+				groupIndex,
+				groupStart,
+				groupRows,
+				ranges,
+				pageRanges,
+				pageLocations
+			});
+		}
+		groupStart = groupEnd;
+	}
+	return {
+		groups,
+		rowEnd: isFinite(rowEnd) ? rowEnd : groupStart
+	};
+}
+function parquetPlanGroup({ rowGroup, groupStart, groupRows, ranges, columns, useOffsetIndex = false, pageRanges, pageLocations }) {
+	const chunks = [];
+	const fetches = [];
+	const indexes = [];
+	const narrowed = ranges.length > 1 || ranges[0][0] > 0 || ranges[0][1] < groupRows;
+	for (const chunk of rowGroup.columns) {
+		const meta = chunk.meta_data;
+		if (chunk.file_path) throw new Error("parquet file_path not supported");
+		if (!meta) throw new Error("parquet column metadata is undefined");
+		if (columns && !columns.includes(meta.path_in_schema[0])) continue;
+		const columnOffset = meta.dictionary_page_offset || meta.data_page_offset;
+		const startByte = Number(columnOffset);
+		const endByte = Number(columnOffset + meta.total_compressed_size);
+		const chunkPageLocations = pageLocations?.[meta.path_in_schema.join(".")];
+		if (chunkPageLocations && narrowed) chunks.push({
+			columnMetadata: meta,
+			pageLocations: chunkPageLocations,
+			range: {
+				startByte,
+				endByte
 			}
-			if (subranges.length) {
-				const chunks = [];
-				const narrowed = subranges.length > 1 || subranges[0][0] > 0 || subranges[0][1] < groupRows;
-				for (const chunk of rowGroup.columns) {
-					const meta = chunk.meta_data;
-					if (chunk.file_path) throw new Error("parquet file_path not supported");
-					if (!meta) throw new Error("parquet column metadata is undefined");
-					if (!columns || columns.includes(meta.path_in_schema[0])) {
-						const columnOffset = meta.dictionary_page_offset || meta.data_page_offset;
-						const startByte = Number(columnOffset);
-						const endByte = Number(columnOffset + meta.total_compressed_size);
-						const chunkPageLocations = pageLocations?.[meta.path_in_schema.join(".")];
-						if (chunkPageLocations && narrowed) chunks.push({
-							columnMetadata: meta,
-							pageLocations: chunkPageLocations,
-							range: {
-								startByte,
-								endByte
-							}
-						});
-						else if ((useOffsetIndex || pageRanges) && chunk.offset_index_offset && chunk.offset_index_length && narrowed) {
-							const offsetIndexStart = Number(chunk.offset_index_offset);
-							chunks.push({
-								columnMetadata: meta,
-								offsetIndex: {
-									startByte: offsetIndexStart,
-									endByte: offsetIndexStart + chunk.offset_index_length
-								},
-								range: {
-									startByte,
-									endByte
-								}
-							});
-						} else chunks.push({
-							columnMetadata: meta,
-							range: {
-								startByte,
-								endByte
-							}
-						});
-					}
-				}
-				for (const [subStart, subEnd] of subranges) groups.push({
-					chunks,
-					rowGroup,
-					groupStart,
-					groupRows,
-					selectStart: subStart,
-					selectEnd: subEnd
-				});
-				let run;
-				for (const chunk of chunks) if ("pageLocations" in chunk) {} else if ("offsetIndex" in chunk) indexes.push(chunk.offsetIndex);
-				else {
-					const { range } = chunk;
-					if (columns) fetches.push(range);
-					else if (run && range.endByte - run.startByte <= runLimit) run.endByte = range.endByte;
-					else {
-						if (run) fetches.push(run);
-						run = { ...range };
-					}
+		});
+		else if ((useOffsetIndex || pageRanges) && chunk.offset_index_offset && chunk.offset_index_length && narrowed) {
+			const startByte = Number(chunk.offset_index_offset);
+			chunks.push({
+				columnMetadata: meta,
+				offsetIndex: {
+					startByte,
+					endByte: startByte + chunk.offset_index_length
+				},
+				range: {
+					startByte: Number(columnOffset),
+					endByte
 				}
-				if (run) fetches.push(run);
+			});
+		} else chunks.push({
+			columnMetadata: meta,
+			range: {
+				startByte,
+				endByte
 			}
+		});
+	}
+	let run;
+	for (const chunk of chunks) {
+		if ("pageLocations" in chunk) continue;
+		if ("offsetIndex" in chunk) indexes.push(chunk.offsetIndex);
+		else if (columns) fetches.push(chunk.range);
+		else if (run && chunk.range.endByte - run.startByte <= runLimit) run.endByte = chunk.range.endByte;
+		else {
+			if (run) fetches.push(run);
+			run = { ...chunk.range };
 		}
-		groupStart = groupEnd;
-		rgIdx++;
 	}
-	if (!isFinite(rowEnd)) rowEnd = groupStart;
-	fetches.push(...indexes);
+	if (run) fetches.push(run);
 	return {
-		metadata,
-		rowStart,
-		rowEnd,
-		columns,
+		groups: ranges.map(([selectStart, selectEnd]) => ({
+			chunks,
+			rowGroup,
+			groupStart,
+			groupRows,
+			selectStart,
+			selectEnd
+		})),
 		fetches,
-		groups
+		indexes
 	};
 }
 function coalesceOverlappingPageRanges(ranges, rowGroup, columns, pageLocations) {
@@ -344,4 +372,4 @@ function prefetchAsyncBuffer(file, { fetches }) {
 		}
 	};
 }
-export { parquetPlan, prefetchAsyncBuffer, prefetchBloomFilters, prefetchPageIndexes };
+export { parquetPlan, parquetPlanGroup, parquetPlanGroups, prefetchAsyncBuffer, prefetchBloomFilters, prefetchPageIndexes };

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/query.mjs

@@ -0,0 +1,3 @@
+import "./metadata.mjs";
+import "./read.mjs";
+export {};

package/dist/node_modules/.pnpm/hyparquet@1.29.2/node_modules/hyparquet/src/read.mjs

@@ -0,0 +1,78 @@
+import { parquetMetadataAsync, parquetSchema } from "./metadata.mjs";
+import { concat } from "./utils.mjs";
+import { columnsNeededForFilter, matchFilter } from "./filter.mjs";
+import "./plan.mjs";
+import { assembleAsync, asyncGroupToRows } from "./rowgroup.mjs";
+import { prepareParquetRead, readParquetPlan } from "./scan.mjs";
+async function parquetRead(options) {
+	options.metadata ??= await parquetMetadataAsync(options.file, options);
+	const { rowStart = 0, rowEnd, columns, onChunk, onComplete, rowFormat, filter, filterStrict = true } = options;
+	if (filter && rowFormat !== "object") throw new Error("parquet filter requires rowFormat: \"object\"");
+	const filterColumns = columnsNeededForFilter(filter);
+	let readColumns = columns;
+	if (columns && filterColumns.length) {
+		const selectedColumns = new Set(columns);
+		const extraColumns = filterColumns.filter((column) => !selectedColumns.has(column));
+		if (extraColumns.length) readColumns = [...columns, ...extraColumns];
+	}
+	const readOptions = readColumns === columns ? options : {
+		...options,
+		columns: readColumns
+	};
+	const prepared = await prepareParquetRead(readOptions);
+	const preparedOptions = prepared.options;
+	const requiresProjection = readColumns !== columns;
+	const asyncGroups = readParquetPlan(preparedOptions, prepared.plan);
+	if (!onComplete && !onChunk) {
+		await awaitAllColumns(asyncGroups);
+		return;
+	}
+	if (!preparedOptions.metadata) throw new Error("parquet requires metadata");
+	const schemaTree = parquetSchema(preparedOptions.metadata);
+	const assembled = asyncGroups.map((arg) => assembleAsync(arg, schemaTree, options.parsers));
+	if (onChunk) for (const asyncGroup of assembled) for (const asyncColumn of asyncGroup.asyncColumns) asyncColumn.data.then(({ data, skipped }) => {
+		let rowStart = asyncGroup.groupStart + skipped;
+		for (const columnData of data) {
+			onChunk({
+				columnName: asyncColumn.pathInSchema[0],
+				columnData,
+				rowStart,
+				rowEnd: rowStart + columnData.length
+			});
+			rowStart += columnData.length;
+		}
+	}, () => {});
+	if (onComplete) {
+		await awaitAllColumns(assembled);
+		const rows = [];
+		for (const asyncGroup of assembled) {
+			const selectStart = asyncGroup.selectStart ?? Math.max(rowStart - asyncGroup.groupStart, 0);
+			const selectEnd = asyncGroup.selectEnd ?? Math.min((rowEnd ?? Infinity) - asyncGroup.groupStart, asyncGroup.groupRows);
+			const groupData = rowFormat === "object" ? await asyncGroupToRows(asyncGroup, selectStart, selectEnd, readColumns, "object") : await asyncGroupToRows(asyncGroup, selectStart, selectEnd, columns, "array");
+			if (filter) {
+				for (const row of groupData) if (matchFilter(row, filter, filterStrict)) {
+					if (requiresProjection && columns) {
+						for (const col of filterColumns) if (!columns.includes(col)) delete row[col];
+					}
+					rows.push(row);
+				}
+			} else concat(rows, groupData);
+		}
+		onComplete(rows);
+	} else await awaitAllColumns(assembled);
+}
+async function awaitAllColumns(asyncGroups) {
+	const all = asyncGroups.flatMap((g) => g.asyncColumns.map((c) => c.data));
+	const failed = (await Promise.allSettled(all)).find((r) => r.status === "rejected");
+	if (failed) throw failed.reason;
+}
+function parquetReadObjects(options) {
+	return new Promise((onComplete, reject) => {
+		parquetRead({
+			...options,
+			rowFormat: "object",
+			onComplete
+		}).catch(reject);
+	});
+}
+export { parquetRead, parquetReadObjects };