@gscdump/lakehouse 2.1.1 → 2.3.0

package/dist/_virtual/node_modules/.pnpm/hyparquet-writer@0.16.6_patch_hash=549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a/node_modules/hyparquet-writer/src/parquet-writer.mjs

@@ -0,0 +1,142 @@
+import { getSchemaPath } from "../../../../hyparquet@1.28.1/node_modules/hyparquet/src/schema.mjs";
+import { writeBlooms } from "./bloom.mjs";
+import { encodeVariantColumn } from "./variant.mjs";
+import { writeColumn } from "./column.mjs";
+import { encodeNestedValues } from "./dremel.mjs";
+import { writeIndexes } from "./indexes.mjs";
+import { writeMetadata } from "./metadata.mjs";
+import { snappyCompress } from "./snappy.mjs";
+var ParquetWriter = class {
+	constructor({ writer, schema, codec = "SNAPPY", compressors, statistics = true, kvMetadata }) {
+		this.writer = writer;
+		this.schema = schema;
+		this.codec = codec;
+		this.compressors = {
+			SNAPPY: snappyCompress,
+			...compressors
+		};
+		this.statistics = statistics;
+		this.kvMetadata = kvMetadata;
+		this.row_groups = [];
+		this.num_rows = 0n;
+		this.pendingIndexes = [];
+		this.writer.appendUint32(827474256);
+	}
+	write({ columnData, rowGroupSize = [1e3, 1e5], pageSize = 1048576, dictionarySize }) {
+		const columnDataRows = columnData[0]?.data?.length || 0;
+		let pending;
+		for (const { groupStartIndex, groupSize } of groupIterator({
+			columnDataRows,
+			rowGroupSize
+		})) {
+			const writeGroup = () => {
+				const groupStartOffset = this.writer.offset;
+				const columns = [];
+				for (let j = 0; j < columnData.length; j++) {
+					const { name, data, encoding, codec = this.codec, columnIndex = false, offsetIndex = true, shredding, bloomFilter } = columnData[j];
+					if (columnIndex && !offsetIndex) throw new Error("parquet ColumnIndex cannot be present without OffsetIndex");
+					if (data.length !== columnDataRows) throw new Error("parquet columns must have the same length");
+					const groupData = data.slice(groupStartIndex, groupStartIndex + groupSize);
+					const columnPath = getSchemaPath(this.schema, [name]);
+					const leafPaths = getLeafSchemaPaths(columnPath);
+					const columnElement = columnPath.at(-1)?.element;
+					const shreddingConfig = shredding && shredding !== true ? shredding : void 0;
+					const isVariant = columnElement?.logical_type?.type === "VARIANT";
+					const isRequired = columnElement?.repetition_type === "REQUIRED";
+					const rows = isVariant ? encodeVariantColumn(Array.from(groupData), shreddingConfig, {
+						name,
+						required: isRequired
+					}) : groupData;
+					for (const leafPath of leafPaths) {
+						const schemaPath = leafPath.map((node) => node.element);
+						const column = {
+							columnName: schemaPath.slice(1).map((s) => s.name).join("."),
+							element: schemaPath[schemaPath.length - 1],
+							schemaPath,
+							codec,
+							compressors: this.compressors,
+							stats: this.statistics,
+							pageSize,
+							dictionarySize,
+							columnIndex,
+							offsetIndex,
+							encoding,
+							bloomFilter
+						};
+						const pageData = encodeNestedValues(leafPath, rows);
+						const result = writeColumn({
+							writer: this.writer,
+							column,
+							pageData
+						});
+						columns.push(result.chunk);
+						this.pendingIndexes.push(result);
+					}
+				}
+				this.num_rows += BigInt(groupSize);
+				this.row_groups.push({
+					columns,
+					total_byte_size: BigInt(this.writer.offset - groupStartOffset),
+					num_rows: BigInt(groupSize)
+				});
+				return this.writer.flush?.();
+			};
+			if (pending) pending = pending.then(writeGroup);
+			else {
+				const r = writeGroup();
+				if (r) pending = Promise.resolve(r);
+			}
+		}
+		return pending;
+	}
+	finish() {
+		writeIndexes(this.writer, this.pendingIndexes);
+		writeBlooms(this.writer, this.pendingIndexes);
+		const metadata = {
+			version: 2,
+			created_by: "hyparquet",
+			schema: this.schema,
+			num_rows: this.num_rows,
+			row_groups: this.row_groups,
+			metadata_length: 0,
+			key_value_metadata: this.kvMetadata
+		};
+		delete metadata.metadata_length;
+		writeMetadata(this.writer, metadata);
+		this.writer.appendUint32(827474256);
+		return this.writer.finish();
+	}
+};
+function groupSize(rowGroupSize, i) {
+	return Array.isArray(rowGroupSize) ? rowGroupSize[Math.min(i, rowGroupSize.length - 1)] : rowGroupSize;
+}
+function groupIterator({ columnDataRows, rowGroupSize }) {
+	if (Array.isArray(rowGroupSize) && !rowGroupSize.length) throw new Error("rowGroupSize array cannot be empty");
+	const groups = [];
+	let groupIndex = 0;
+	let groupStartIndex = 0;
+	while (groupStartIndex < columnDataRows) {
+		const size = groupSize(rowGroupSize, groupIndex);
+		groups.push({
+			groupStartIndex,
+			groupSize: Math.min(size, columnDataRows - groupStartIndex)
+		});
+		groupStartIndex += size;
+		groupIndex++;
+	}
+	return groups;
+}
+function getLeafSchemaPaths(schemaPath) {
+	const leaves = [];
+	dfs(schemaPath);
+	return leaves;
+	function dfs(path) {
+		const node = path[path.length - 1];
+		if (!node.children.length) {
+			leaves.push(path);
+			return;
+		}
+		for (const child of node.children) dfs([...path, child]);
+	}
+}
+export { ParquetWriter, groupSize };

package/dist/_virtual/node_modules/.pnpm/{hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec → hyparquet-writer@0.16.6_patch_hash=549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a}/node_modules/hyparquet-writer/src/schema.mjs

@@ -232,7 +232,7 @@ function autoSchemaElement(name, values) {
 			type = valueType;
 			converted_type = valueConvertedType;
 		} else if (type === "INT32" && valueType === "DOUBLE") type = "DOUBLE";
-		else if (type === "DOUBLE" && valueType === "INT32") valueType = "DOUBLE";
+		else if (type === "DOUBLE" && valueType === "INT32") continue;
 		else if (type !== valueType || converted_type !== valueConvertedType) throw new Error(`parquet cannot write mixed types: ${converted_type ?? type} and ${valueConvertedType ?? valueType}`);
 	}
 	if (!type) {

package/dist/_virtual/node_modules/.pnpm/{hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec → hyparquet-writer@0.16.6_patch_hash=549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a}/node_modules/hyparquet-writer/src/thrift.mjs

@@ -4,10 +4,14 @@ const FALSE = 2;
 const BYTE = 3;
 const I32 = 5;
 const I64 = 6;
-const DOUBLE = 7;
 const BINARY = 8;
 const LIST = 9;
 const STRUCT = 12;
+var ThriftStruct = class {
+	constructor(fields) {
+		this.fields = fields;
+	}
+};
 function serializeTCompactProtocol(writer, data) {
 	writeElement(writer, STRUCT, data);
 }
@@ -17,7 +21,7 @@ function writeElement(writer, type, value) {
 	if (type === BYTE && typeof value === "number") writer.appendUint8(value);
 	else if (type === I32 && typeof value === "number") writer.appendZigZag(value);
 	else if (type === I64 && typeof value === "bigint") writer.appendZigZag(value);
-	else if (type === DOUBLE && typeof value === "number") writer.appendFloat64(value);
+	else if (type === 7 && typeof value === "number") writer.appendFloat64(value);
 	else if (type === BINARY && typeof value === "string") {
 		const bytes = new TextEncoder().encode(value);
 		writer.appendVarInt(bytes.length);
@@ -33,6 +37,13 @@ function writeElement(writer, type, value) {
 		} else writer.appendUint8(value.length << 4 | elemType);
 		if (elemType === FALSE) for (const v of value) writer.appendUint8(v ? 1 : 0);
 		else for (const v of value) writeElement(writer, elemType, v);
+	} else if (type === STRUCT && value instanceof ThriftStruct) {
+		let lastFid = 0;
+		for (const [fid, fieldType, fieldValue] of value.fields) {
+			if (fieldValue === void 0) continue;
+			lastFid = writeStructField(writer, lastFid, fid, fieldType, fieldValue);
+		}
+		writer.appendUint8(STOP);
 	} else if (type === STRUCT && typeof value === "object") {
 		let lastFid = 0;
 		for (const [k, v] of Object.entries(value)) {
@@ -40,23 +51,26 @@ function writeElement(writer, type, value) {
 			const fid = parseInt(k.replace(/^field_/, ""), 10);
 			if (Number.isNaN(fid)) throw new Error(`thrift invalid field name: ${k}. Expected "field_###"`);
 			const t = getCompactTypeForValue(v);
-			const delta = fid - lastFid;
-			if (delta <= 0) throw new Error(`thrift non-monotonic field id: fid=${fid}, lastFid=${lastFid}`);
-			if (delta > 15) {
-				writer.appendUint8(t);
-				writer.appendZigZag(fid);
-			} else writer.appendUint8(delta << 4 | t);
-			writeElement(writer, t, v);
-			lastFid = fid;
+			lastFid = writeStructField(writer, lastFid, fid, t, v);
 		}
 		writer.appendUint8(STOP);
 	} else throw new Error(`thrift invalid type ${type} for value ${value}`);
 }
+function writeStructField(writer, lastFid, fid, type, value) {
+	const delta = fid - lastFid;
+	if (delta <= 0) throw new Error(`thrift non-monotonic field id: fid=${fid}, lastFid=${lastFid}`);
+	if (delta > 15) {
+		writer.appendUint8(type);
+		writer.appendZigZag(fid);
+	} else writer.appendUint8(delta << 4 | type);
+	writeElement(writer, type, value);
+	return fid;
+}
 function getCompactTypeForValue(value) {
 	if (value === true) return TRUE;
 	if (value === false) return FALSE;
 	if (Number.isInteger(value)) return I32;
-	if (typeof value === "number") return DOUBLE;
+	if (typeof value === "number") return 7;
 	if (typeof value === "bigint") return I64;
 	if (typeof value === "string") return BINARY;
 	if (value instanceof Uint8Array) return BINARY;
@@ -70,10 +84,10 @@ function getCompactTypeForList(value) {
 		let t = getCompactTypeForValue(v);
 		if (t === TRUE) t = FALSE;
 		if (!elemType) elemType = t;
-		if (elemType === DOUBLE && t === I32) t = DOUBLE;
-		if (elemType === I32 && t === DOUBLE) elemType = DOUBLE;
+		if (elemType === 7 && t === I32) t = 7;
+		if (elemType === I32 && t === 7) elemType = 7;
 		if (t !== elemType) throw new Error(`thrift invalid type for list element: ${v} (expected type ${elemType})`);
 	}
 	return elemType ?? BYTE;
 }
-export { serializeTCompactProtocol };
+export { ThriftStruct, serializeTCompactProtocol };

package/dist/_virtual/node_modules/.pnpm/{hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec → hyparquet-writer@0.16.6_patch_hash=549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a}/node_modules/hyparquet-writer/src/types.d.mts

@@ -1,4 +1,4 @@
-import "../../../../hyparquet@1.26.1/node_modules/hyparquet/types/node.mjs";
+import "../../../../hyparquet@1.28.1/node_modules/hyparquet/types/node.mjs";
 interface Writer {
   buffer: ArrayBuffer;
   view: DataView;

package/dist/_virtual/node_modules/.pnpm/{hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec → hyparquet-writer@0.16.6_patch_hash=549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a}/node_modules/hyparquet-writer/src/unconvert.mjs

@@ -1,7 +1,16 @@
-import { toJson } from "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/utils.mjs";
-import "../../../../hyparquet@1.26.1/node_modules/hyparquet/src/node.mjs";
+import { toJson } from "../../../../hyparquet@1.28.1/node_modules/hyparquet/src/utils.mjs";
+import "../../../../hyparquet@1.28.1/node_modules/hyparquet/src/node.mjs";
 import { geojsonToWkb } from "./wkb.mjs";
 const dayMillis = 864e5;
+function mapConverted(values, convert) {
+	const cache = /* @__PURE__ */ new Map();
+	return Array.from(values, (value) => {
+		if (cache.has(value)) return cache.get(value);
+		const result = convert(value);
+		cache.set(value, result);
+		return result;
+	});
+}
 function unconvert(element, values) {
 	const { type, converted_type: ctype, logical_type: ltype } = element;
 	if (ctype === "DECIMAL") {
@@ -29,7 +38,7 @@ function unconvert(element, values) {
 	if (ctype === "JSON") {
 		if (!Array.isArray(values)) throw new Error("JSON must be an array");
 		const encoder = new TextEncoder();
-		return values.map((v) => v === void 0 ? void 0 : encoder.encode(JSON.stringify(toJson(v))));
+		return mapConverted(values, (v) => v === null || v === void 0 ? v : encoder.encode(JSON.stringify(toJson(v))));
 	}
 	if (ctype === "UTF8") {
 		if (!Array.isArray(values)) throw new Error("strings must be an array");
@@ -70,7 +79,7 @@ function unconvert(element, values) {
 	});
 	if (ltype?.type === "GEOMETRY" || ltype?.type === "GEOGRAPHY") {
 		if (!Array.isArray(values)) throw new Error("geometry must be an array");
-		return values.map((v) => {
+		return mapConverted(values, (v) => {
 			if (v === null || v === void 0) return v;
 			return geojsonToWkb(v);
 		});

package/dist/_virtual/node_modules/.pnpm/{hyparquet-writer@0.16.1_patch_hash=7a5e451ac7634d7546ac56bcc5eadacf7715a6241640c2b5a5bc0cfc9763b8ec → hyparquet-writer@0.16.6_patch_hash=549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a}/node_modules/hyparquet-writer/src/write.mjs

@@ -2,7 +2,7 @@ import "./bytewriter.mjs";
 import { autoDetectShredding, normalizeShreddingConfig } from "./variant.mjs";
 import { schemaFromColumnData } from "./schema.mjs";
 import { ParquetWriter } from "./parquet-writer.mjs";
-function parquetWrite({ writer, columnData, schema, codec = "SNAPPY", compressors, statistics = true, rowGroupSize = [1e3, 1e5], kvMetadata, pageSize = 1048576 }) {
+function parquetWrite({ writer, columnData, schema, codec = "SNAPPY", compressors, statistics = true, rowGroupSize = [1e3, 1e5], kvMetadata, pageSize = 1048576, dictionarySize }) {
 	columnData = columnData.map((col) => {
 		if (col.shredding === true && col.type === "VARIANT") {
 			const detected = autoDetectShredding(Array.from(col.data));
@@ -39,7 +39,8 @@ function parquetWrite({ writer, columnData, schema, codec = "SNAPPY", compressor
 	const w = pq.write({
 		columnData,
 		rowGroupSize,
-		pageSize
+		pageSize,
+		dictionarySize
 	});
 	return w ? w.then(() => pq.finish()) : pq.finish();
 }

package/dist/_virtual/node_modules/.pnpm/hyparquet-writer@0.16.6_patch_hash=549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a/node_modules/hyparquet-writer/types/index.d.mts

@@ -0,0 +1,18 @@
+import "../../../../hyparquet@1.28.1/node_modules/hyparquet/types/node.mjs";
+import { Writer as Writer$1 } from "../src/types.mjs";
+import "./write.mjs";
+import "./write-rows.mjs";
+import "./schema.mjs";
+import "./bytewriter.mjs";
+import "./parquet-writer.mjs";
+import "./wkb.mjs";
+type Writer = Writer$1;
+/**
+ * @typedef {import('hyparquet').KeyValue} KeyValue
+ * @typedef {import('hyparquet').SchemaElement} SchemaElement
+ * @typedef {import('../src/types.d.ts').BasicType} BasicType
+ * @typedef {import('../src/types.d.ts').ColumnSource} ColumnSource
+ * @typedef {import('../src/types.d.ts').ParquetWriteOptions} ParquetWriteOptions
+ * @typedef {import('../src/types.d.ts').Writer} Writer
+ */
+export { Writer };

package/dist/_virtual/node_modules/.pnpm/hyparquet-writer@0.16.6_patch_hash=549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a/node_modules/hyparquet-writer/types/parquet-writer.d.mts

@@ -0,0 +1,2 @@
+import "../../../../hyparquet@1.28.1/node_modules/hyparquet/types/node.mjs";
+import "../src/types.mjs";

package/dist/_virtual/node_modules/.pnpm/hyparquet-writer@0.16.6_patch_hash=549d1fd1fb9614da77df9123bf6978a8fccfe1d9bb8882863ce6159f666e821a/node_modules/hyparquet-writer/types/schema.d.mts

@@ -0,0 +1,2 @@
+import "../../../../hyparquet@1.28.1/node_modules/hyparquet/types/node.mjs";
+import "../src/types.mjs";

package/dist/_virtual/node_modules/.pnpm/{hyparquet@1.26.1 → hyparquet@1.28.1}/node_modules/hyparquet/src/filter.mjs

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

package/dist/_virtual/node_modules/.pnpm/{hyparquet@1.26.1 → hyparquet@1.28.1}/node_modules/hyparquet/src/plan.mjs

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

package/dist/_virtual/node_modules/.pnpm/{hyparquet@1.26.1 → hyparquet@1.28.1}/node_modules/hyparquet/types/index.d.mts

@@ -1,7 +1,7 @@
 import "../src/types.mjs";
-import "./query.mjs";
-import "./snappy.mjs";
 import "./indexes.mjs";
 import "./metadata.mjs";
 import "./read.mjs";
+import "./query.mjs";
+import "./snappy.mjs";
 import "./utils.mjs";

package/dist/_virtual/node_modules/.pnpm/{hyparquet@1.26.2 → hyparquet@1.28.2}/node_modules/hyparquet/src/constants.mjs

@@ -65,6 +65,11 @@ const PageTypes = [
 	"DICTIONARY_PAGE",
 	"DATA_PAGE_V2"
 ];
+const BoundaryOrders = [
+	"UNORDERED",
+	"ASCENDING",
+	"DESCENDING"
+];
 const EdgeInterpolationAlgorithms = [
 	"SPHERICAL",
 	"VINCENTY",
@@ -72,4 +77,4 @@ const EdgeInterpolationAlgorithms = [
 	"ANDOYER",
 	"KARNEY"
 ];
-export { CompressionCodecs, ConvertedTypes, EdgeInterpolationAlgorithms, Encodings, FieldRepetitionTypes, PageTypes, ParquetTypes };
+export { BoundaryOrders, CompressionCodecs, ConvertedTypes, EdgeInterpolationAlgorithms, Encodings, FieldRepetitionTypes, PageTypes, ParquetTypes };

package/dist/_virtual/node_modules/.pnpm/hyparquet@1.28.2/node_modules/hyparquet/src/filter.mjs

@@ -0,0 +1,212 @@
+import { hashParquetValue, sbbfContains } from "./bloom.mjs";
+import { equals } from "./utils.mjs";
+const encoder = new TextEncoder();
+function pathsNeededForFilter(filter) {
+	if (!filter) return [];
+	const paths = [];
+	if ("$and" in filter && Array.isArray(filter.$and)) paths.push(...filter.$and.flatMap(pathsNeededForFilter));
+	else if ("$or" in filter && Array.isArray(filter.$or)) paths.push(...filter.$or.flatMap(pathsNeededForFilter));
+	else if ("$nor" in filter && Array.isArray(filter.$nor)) paths.push(...filter.$nor.flatMap(pathsNeededForFilter));
+	else paths.push(...Object.keys(filter));
+	return [...new Set(paths)];
+}
+function columnsNeededForFilter(filter) {
+	return [...new Set(pathsNeededForFilter(filter).map((path) => path.split(".")[0]))];
+}
+function matchFilter(record, filter, strict = true) {
+	if ("$and" in filter && Array.isArray(filter.$and)) return filter.$and.every((subQuery) => matchFilter(record, subQuery, strict));
+	if ("$or" in filter && Array.isArray(filter.$or)) return filter.$or.some((subQuery) => matchFilter(record, subQuery, strict));
+	if ("$nor" in filter && Array.isArray(filter.$nor)) return !filter.$nor.some((subQuery) => matchFilter(record, subQuery, strict));
+	return Object.entries(filter).every(([field, condition]) => {
+		const value = resolve(record, field);
+		if (typeof condition !== "object" || condition === null || Array.isArray(condition)) return equals(value, condition, strict);
+		return Object.entries(condition || {}).every(([operator, target]) => {
+			if (operator === "$gt") return value !== null && value !== void 0 && value > target;
+			if (operator === "$gte") return value !== null && value !== void 0 && value >= target;
+			if (operator === "$lt") return value !== null && value !== void 0 && value < target;
+			if (operator === "$lte") return value !== null && value !== void 0 && value <= target;
+			if (operator === "$eq") return equals(value, target, strict);
+			if (operator === "$ne") return !equals(value, target, strict);
+			if (operator === "$in") return Array.isArray(target) && matchesIn(value, target, strict);
+			if (operator === "$nin") return Array.isArray(target) && !matchesIn(value, target, strict);
+			if (operator === "$not") return !matchFilter({ [field]: value }, { [field]: target }, strict);
+			return true;
+		});
+	});
+}
+function matchesIn(value, targets, strict) {
+	return targets.some((target) => equals(value, target, strict) || Array.isArray(value) && value.some((element) => equals(element, target, strict)));
+}
+function canSkipRowGroup({ rowGroup, physicalColumns, filter, strict = true, bloomFilters, schemaElements }) {
+	if (!filter) return false;
+	if ("$and" in filter && Array.isArray(filter.$and)) return filter.$and.some((subFilter) => canSkipRowGroup({
+		rowGroup,
+		physicalColumns,
+		filter: subFilter,
+		strict,
+		bloomFilters,
+		schemaElements
+	}));
+	if ("$or" in filter && Array.isArray(filter.$or)) return filter.$or.every((subFilter) => canSkipRowGroup({
+		rowGroup,
+		physicalColumns,
+		filter: subFilter,
+		strict,
+		bloomFilters,
+		schemaElements
+	}));
+	if ("$nor" in filter && Array.isArray(filter.$nor)) return false;
+	for (const [field, condition] of Object.entries(filter)) {
+		const columnIndex = physicalColumns.indexOf(field);
+		if (columnIndex === -1) continue;
+		const { min, max, min_value, max_value, null_count: nullCount } = rowGroup.columns[columnIndex].meta_data?.statistics || {};
+		const minVal = min_value !== void 0 ? min_value : min;
+		const maxVal = max_value !== void 0 ? max_value : max;
+		const haveStats = minVal !== void 0 && maxVal !== void 0;
+		const bloom = bloomFilters?.[field];
+		const element = schemaElements?.[field];
+		const matchingNulls = matchFilter({ value: null }, { value: condition }, strict) && (nullCount === void 0 || nullCount > 0);
+		if (haveStats && !matchingNulls && canSkipStats(condition, minVal, maxVal, strict, element)) return true;
+		for (const [operator, target] of Object.entries(condition || {})) if (bloom && element) {
+			if (operator === "$eq") {
+				const hash = hashParquetValue(target, element);
+				if (hash !== void 0 && !sbbfContains(bloom.blocks, hash)) return true;
+			}
+			if (operator === "$in" && Array.isArray(target) && target.length > 0) {
+				let allAbsent = true;
+				for (const v of target) {
+					const h = hashParquetValue(v, element);
+					if (h === void 0 || sbbfContains(bloom.blocks, h)) {
+						allAbsent = false;
+						break;
+					}
+				}
+				if (allAbsent) return true;
+			}
+		}
+	}
+	return false;
+}
+function canSkipStats(condition, minVal, maxVal, strict, element) {
+	if (minVal === void 0 || maxVal === void 0) return false;
+	const mayContainNaN = element?.type === "FLOAT" || element?.type === "DOUBLE" || element?.logical_type?.type === "FLOAT16";
+	for (const [operator, target] of Object.entries(condition || {})) {
+		const minComparison = compareParquetValues(minVal, target, strict, element);
+		const maxComparison = compareParquetValues(maxVal, target, strict, element);
+		const relationalBoundsAreSafe = !(minVal instanceof Uint8Array || maxVal instanceof Uint8Array) && (element?.type !== "BYTE_ARRAY" || typeof target === "string" && [...target].every((character) => character.charCodeAt(0) <= 127));
+		if (operator === "$gt" && relationalBoundsAreSafe && maxComparison !== void 0 && maxComparison <= 0) return true;
+		if (operator === "$gte" && relationalBoundsAreSafe && maxComparison !== void 0 && maxComparison < 0) return true;
+		if (operator === "$lt" && relationalBoundsAreSafe && minComparison !== void 0 && minComparison >= 0) return true;
+		if (operator === "$lte" && relationalBoundsAreSafe && minComparison !== void 0 && minComparison > 0) return true;
+		if (operator === "$eq") {
+			const targetMinComparison = compareParquetValues(target, minVal, strict, element);
+			const targetMaxComparison = compareParquetValues(target, maxVal, strict, element);
+			if (targetMinComparison !== void 0 && targetMinComparison < 0 || targetMaxComparison !== void 0 && targetMaxComparison > 0) return true;
+		}
+		if (operator === "$ne" && !mayContainNaN && equals(minVal, maxVal, strict) && equals(minVal, target, strict)) return true;
+		if (operator === "$in" && Array.isArray(target) && target.every((value) => {
+			const valueMinComparison = compareParquetValues(value, minVal, strict, element);
+			const valueMaxComparison = compareParquetValues(value, maxVal, strict, element);
+			return valueMinComparison !== void 0 && valueMinComparison < 0 || valueMaxComparison !== void 0 && valueMaxComparison > 0;
+		})) return true;
+		if (operator === "$nin" && !mayContainNaN && Array.isArray(target) && equals(minVal, maxVal, strict) && target.some((value) => equals(minVal, value, strict))) return true;
+	}
+	return false;
+}
+function compareParquetValues(a, b, strict, element) {
+	if (element?.type === "BYTE_ARRAY") {
+		if (typeof a !== "string" || typeof b !== "string") return void 0;
+		return compareBytes(encoder.encode(a), encoder.encode(b));
+	}
+	if (a instanceof Uint8Array || b instanceof Uint8Array) {
+		if (!(a instanceof Uint8Array) || !(b instanceof Uint8Array)) return void 0;
+		return compareBytes(a, b);
+	}
+	if (a < b) return -1;
+	if (a > b) return 1;
+	if (equals(a, b, strict)) return 0;
+}
+function compareBytes(a, b) {
+	const length = Math.min(a.length, b.length);
+	for (let i = 0; i < length; i++) {
+		if (a[i] < b[i]) return -1;
+		if (a[i] > b[i]) return 1;
+	}
+	if (a.length < b.length) return -1;
+	if (a.length > b.length) return 1;
+	return 0;
+}
+function matchesNull(condition, strict) {
+	return matchFilter({ value: null }, { value: condition }, strict);
+}
+function filterPageRanges(filter, columnPages, groupRows, strict = true) {
+	if (!filter) return void 0;
+	if ("$and" in filter && Array.isArray(filter.$and)) {
+		let ranges;
+		for (const subFilter of filter.$and) ranges = intersectRanges(ranges, filterPageRanges(subFilter, columnPages, groupRows, strict));
+		return ranges;
+	}
+	if ("$or" in filter && Array.isArray(filter.$or)) {
+		let ranges = [];
+		for (const subFilter of filter.$or) {
+			const subRanges = filterPageRanges(subFilter, columnPages, groupRows, strict);
+			if (!subRanges) return void 0;
+			ranges = unionRanges(ranges, subRanges);
+		}
+		return ranges;
+	}
+	if ("$nor" in filter && Array.isArray(filter.$nor)) return;
+	let result;
+	for (const [field, condition] of Object.entries(filter)) {
+		const pages = columnPages[field];
+		if (!pages) continue;
+		const nullCanMatch = matchesNull(condition, strict);
+		const keep = [];
+		for (let i = 0; i < pages.pageStarts.length; i++) {
+			const start = pages.pageStarts[i];
+			const end = i + 1 < pages.pageStarts.length ? pages.pageStarts[i + 1] : groupRows;
+			const nullCount = pages.nullCounts?.[i];
+			const matchingNulls = nullCanMatch && (nullCount === void 0 || nullCount > 0);
+			if (!(!pages.nullPages[i] && !matchingNulls && canSkipStats(condition, pages.minValues[i], pages.maxValues[i], strict, pages.element))) {
+				const last = keep[keep.length - 1];
+				if (last && last[1] === start) last[1] = end;
+				else keep.push([start, end]);
+			}
+		}
+		result = intersectRanges(result, keep);
+	}
+	return result;
+}
+function intersectRanges(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) {
+		const start = Math.max(a[i][0], b[j][0]);
+		const end = Math.min(a[i][1], b[j][1]);
+		if (start < end) out.push([start, end]);
+		if (a[i][1] < b[j][1]) i++;
+		else j++;
+	}
+	return out;
+}
+function unionRanges(a, b) {
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length || j < b.length) {
+		const next = j >= b.length || i < a.length && a[i][0] <= b[j][0] ? a[i++] : b[j++];
+		const last = out[out.length - 1];
+		if (last && next[0] <= last[1]) last[1] = Math.max(last[1], next[1]);
+		else out.push([next[0], next[1]]);
+	}
+	return out;
+}
+function resolve(record, path) {
+	let value = record;
+	for (const part of path.split(".")) value = value?.[part];
+	return value;
+}
+export { canSkipRowGroup, columnsNeededForFilter, filterPageRanges, intersectRanges, matchFilter, pathsNeededForFilter, unionRanges };

package/dist/_virtual/node_modules/.pnpm/hyparquet@1.28.2/node_modules/hyparquet/src/indexes.mjs

@@ -0,0 +1,32 @@
+import { BoundaryOrders } from "./constants.mjs";
+import { DEFAULT_PARSERS } from "./convert.mjs";
+import { deserializeTCompactProtocol } from "./thrift.mjs";
+import { convertMetadata } from "./metadata.mjs";
+function readColumnIndex(reader, schema, parsers = void 0) {
+	parsers = {
+		...DEFAULT_PARSERS,
+		...parsers
+	};
+	const thrift = deserializeTCompactProtocol(reader);
+	return {
+		null_pages: thrift.field_1,
+		min_values: thrift.field_2.map((m) => convertMetadata(m, schema, parsers)),
+		max_values: thrift.field_3.map((m) => convertMetadata(m, schema, parsers)),
+		boundary_order: BoundaryOrders[thrift.field_4],
+		null_counts: thrift.field_5,
+		repetition_level_histograms: thrift.field_6,
+		definition_level_histograms: thrift.field_7
+	};
+}
+function readOffsetIndex(reader) {
+	const thrift = deserializeTCompactProtocol(reader);
+	return {
+		page_locations: thrift.field_1.map((loc) => ({
+			offset: loc.field_1,
+			compressed_page_size: loc.field_2,
+			first_row_index: loc.field_3
+		})),
+		unencoded_byte_array_data_bytes: thrift.field_2
+	};
+}
+export { readColumnIndex, readOffsetIndex };

package/dist/_virtual/node_modules/.pnpm/{hyparquet@1.26.2 → hyparquet@1.28.2}/node_modules/hyparquet/src/metadata.mjs

@@ -219,12 +219,17 @@ function convertMetadata(value, schema, parsers) {
 	const view = new DataView(value.buffer, value.byteOffset, value.byteLength);
 	if (type === "FLOAT" && view.byteLength === 4) return view.getFloat32(0, true);
 	if (type === "DOUBLE" && view.byteLength === 8) return view.getFloat64(0, true);
+	if (type === "INT32" && converted_type === "DECIMAL" && view.byteLength === 4) return view.getInt32(0, true) * 10 ** -(schema.scale || 0);
+	if (type === "INT64" && converted_type === "DECIMAL" && view.byteLength === 8) return Number(view.getBigInt64(0, true)) * 10 ** -(schema.scale || 0);
 	if (type === "INT32" && converted_type === "DATE") return parsers.dateFromDays(view.getInt32(0, true));
 	if (type === "INT64" && converted_type === "TIMESTAMP_MILLIS") return parsers.timestampFromMilliseconds(view.getBigInt64(0, true));
 	if (type === "INT64" && converted_type === "TIMESTAMP_MICROS") return parsers.timestampFromMicroseconds(view.getBigInt64(0, true));
 	if (type === "INT64" && logical_type?.type === "TIMESTAMP" && logical_type?.unit === "NANOS") return parsers.timestampFromNanoseconds(view.getBigInt64(0, true));
 	if (type === "INT64" && logical_type?.type === "TIMESTAMP" && logical_type?.unit === "MICROS") return parsers.timestampFromMicroseconds(view.getBigInt64(0, true));
 	if (type === "INT64" && logical_type?.type === "TIMESTAMP") return parsers.timestampFromMilliseconds(view.getBigInt64(0, true));
+	const unsigned = converted_type?.startsWith("UINT_") || logical_type?.type === "INTEGER" && !logical_type.isSigned;
+	if (type === "INT32" && unsigned && view.byteLength === 4) return view.getUint32(0, true);
+	if (type === "INT64" && unsigned && view.byteLength === 8) return view.getBigUint64(0, true);
 	if (type === "INT32" && view.byteLength === 4) return view.getInt32(0, true);
 	if (type === "INT64" && view.byteLength === 8) return view.getBigInt64(0, true);
 	if (converted_type === "DECIMAL") return parseDecimal(value) * 10 ** -(schema.scale || 0);