@gscdump/lakehouse 1.4.0 → 1.4.2

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/stage-deletion-vector.mjs

@@ -0,0 +1,295 @@
+import { writeDeletionVector } from "../puffin/deletion-vector.mjs";
+import { writePuffinFile } from "../puffin/puffin.mjs";
+import { uuid4 } from "../utils.mjs";
+import { fetchDeleteMaps } from "../fetch.mjs";
+import { validateSchemaForVersion } from "../schema.mjs";
+import { deleteFileAppliesToDataEntry } from "../delete.mjs";
+import { writeDeleteManifest, writeExistingDeleteManifest } from "./manifest.mjs";
+import { buildPartitionSummaries, buildSnapshotUpdate, currentSnapshot, loadPriorManifests } from "./snapshot.mjs";
+import { checkWriteFormat, newSnapshotId } from "./stage.mjs";
+import { findDataFileEntries, loadManifestEntries, partitionTupleKey } from "./stage-position-delete.mjs";
+async function icebergStageDeletionVector({ tableUrl, metadata, deletes, resolver }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	if (!Array.isArray(deletes) || !deletes.length) throw new Error("deletes must be a non-empty array");
+	const writerFn = resolver.writer;
+	if (metadata["format-version"] !== 3) throw new Error("icebergStageDeletionVector requires format-version 3");
+	const formatVersion = 3;
+	if (!metadata["partition-specs"].find((s) => s["spec-id"] === metadata["default-spec-id"])) throw new Error("default partition spec not found in metadata");
+	const schema = metadata.schemas.find((s) => s["schema-id"] === metadata["current-schema-id"]);
+	if (!schema) throw new Error("current schema not found in metadata");
+	validateSchemaForVersion(schema, formatVersion);
+	const snapshotId = newSnapshotId();
+	const sequenceNumber = BigInt(metadata["last-sequence-number"] ?? 0) + 1n;
+	const manifestUuid = uuid4();
+	const timestampMs = Date.now();
+	checkWriteFormat(metadata.properties?.["write.format.default"]);
+	const dataFileMap = await findDataFileEntries(metadata, resolver);
+	const byFile = /* @__PURE__ */ new Map();
+	for (const d of deletes) {
+		if (typeof d.file_path !== "string" || !d.file_path) throw new Error("deletion vector file_path must be a non-empty string");
+		if (d.pos === void 0 || d.pos === null) throw new Error("deletion vector pos is required");
+		const pos = typeof d.pos === "bigint" ? d.pos : BigInt(d.pos);
+		if (pos < 0n) throw new Error(`deletion vector pos must be non-negative: ${pos}`);
+		let entry = byFile.get(d.file_path);
+		if (!entry) {
+			const found = dataFileMap.get(d.file_path);
+			if (!found) throw new Error(`target data file not found in current snapshot: ${d.file_path}`);
+			entry = {
+				positions: /* @__PURE__ */ new Set(),
+				partition: found.partition,
+				partitionSpecId: found.partitionSpecId,
+				dataEntry: found.entry
+			};
+			byFile.set(d.file_path, entry);
+		}
+		entry.positions.add(pos);
+	}
+	const priorManifests = await loadPriorManifests(metadata, resolver);
+	const priorDeleteManifests = await loadPriorDeleteManifestEntries(priorManifests, resolver);
+	const priorPositionDeleteEntries = priorDeleteManifests.flatMap((m) => m.entries).filter((entry) => entry.data_file.content === 1);
+	const targetPaths = new Set(byFile.keys());
+	const obsoletePositionDeleteEntries = /* @__PURE__ */ new Set();
+	if (priorPositionDeleteEntries.length) {
+		const { positionDeletesMap } = await fetchDeleteMaps(priorPositionDeleteEntries, resolver);
+		const positionDeleteTargets = /* @__PURE__ */ new Map();
+		for (const [targetPath, groups] of positionDeletesMap) for (const group of groups) {
+			let targets = positionDeleteTargets.get(group.deleteEntry);
+			if (!targets) {
+				targets = /* @__PURE__ */ new Set();
+				positionDeleteTargets.set(group.deleteEntry, targets);
+			}
+			targets.add(targetPath);
+		}
+		for (const [targetPath, info] of byFile) {
+			const groups = positionDeletesMap.get(targetPath) ?? [];
+			for (const group of groups) {
+				if (!deleteFileAppliesToDataEntry(info.dataEntry, group.deleteEntry, metadata, "position")) continue;
+				for (const pos of group.positions) info.positions.add(pos);
+			}
+		}
+		for (const [entry, coveredTargets] of positionDeleteTargets) {
+			if (isDeletionVectorForTarget(entry, targetPaths)) continue;
+			let allTargetsCovered = true;
+			let appliesToTarget = false;
+			for (const targetPath of coveredTargets) {
+				if (!targetPaths.has(targetPath)) {
+					allTargetsCovered = false;
+					break;
+				}
+				const info = byFile.get(targetPath);
+				if (info && deleteFileAppliesToDataEntry(info.dataEntry, entry, metadata, "position")) appliesToTarget = true;
+			}
+			if (allTargetsCovered && appliesToTarget) obsoletePositionDeleteEntries.add(entry);
+		}
+	}
+	const skipPriorManifestPaths = /* @__PURE__ */ new Set();
+	const replacementManifests = [];
+	const replacementManifestPaths = [];
+	let replacementIndex = 0;
+	let removedDeleteFiles = 0n;
+	let removedPositionDeletes = 0n;
+	let removedDvs = 0n;
+	for (const { manifest, entries } of priorDeleteManifests) {
+		const obsolete = entries.filter((entry) => isObsoleteDeleteEntry(entry, targetPaths, obsoletePositionDeleteEntries));
+		if (!obsolete.length) continue;
+		skipPriorManifestPaths.add(manifest.manifest_path);
+		removedDeleteFiles += BigInt(obsolete.length);
+		removedPositionDeletes += obsolete.reduce((sum, entry) => sum + entry.data_file.record_count, 0n);
+		removedDvs += BigInt(obsolete.filter((entry) => isDeletionVectorForTarget(entry, targetPaths)).length);
+		const retained = entries.filter((entry) => !isObsoleteDeleteEntry(entry, targetPaths, obsoletePositionDeleteEntries)).map((entry) => ({
+			...entry,
+			status: 0
+		}));
+		if (!retained.length) continue;
+		const spec = metadata["partition-specs"].find((s) => s["spec-id"] === manifest.partition_spec_id);
+		if (!spec) throw new Error(`partition spec ${manifest.partition_spec_id} not found in metadata`);
+		const manifestPath = `${tableUrl}/metadata/${manifestUuid}-r${replacementIndex}.avro`;
+		const manifestWriter = writerFn(manifestPath);
+		await writeExistingDeleteManifest({
+			writer: manifestWriter,
+			schema,
+			partitionSpec: spec,
+			entries: retained,
+			formatVersion
+		});
+		const existingRows = retained.reduce((sum, entry) => sum + entry.data_file.record_count, 0n);
+		replacementManifests.push({
+			manifest_path: manifestPath,
+			manifest_length: BigInt(manifestWriter.offset),
+			partition_spec_id: spec["spec-id"],
+			content: 1,
+			sequence_number: sequenceNumber,
+			min_sequence_number: minEntrySequenceNumber(retained, sequenceNumber),
+			added_snapshot_id: snapshotId,
+			added_files_count: 0,
+			existing_files_count: retained.length,
+			deleted_files_count: 0,
+			added_rows_count: 0n,
+			existing_rows_count: existingRows,
+			deleted_rows_count: 0n,
+			partitions: manifest.partitions ?? []
+		});
+		replacementManifestPaths.push(manifestPath);
+		replacementIndex++;
+	}
+	const writtenPuffinPaths = [];
+	const writtenDeleteFiles = await Promise.all([...byFile.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(async ([targetPath, info]) => {
+		const blob = writeDeletionVector(info.positions);
+		const puffin = writePuffinFile({ blobs: [{
+			type: "deletion-vector-v1",
+			fields: [],
+			snapshotId: -1,
+			sequenceNumber: -1,
+			data: blob,
+			properties: {
+				"referenced-data-file": targetPath,
+				cardinality: String(info.positions.size)
+			}
+		}] });
+		const puffinPath = `${tableUrl}/data/${uuid4()}-deletes.puffin`;
+		const puffinWriter = writerFn(puffinPath);
+		puffinWriter.appendBytes(puffin);
+		await puffinWriter.finish();
+		writtenPuffinPaths.push(puffinPath);
+		const deleteFile = {
+			content: 1,
+			file_path: puffinPath,
+			file_format: "puffin",
+			partition: info.partition,
+			record_count: BigInt(info.positions.size),
+			file_size_in_bytes: BigInt(puffinWriter.offset),
+			referenced_data_file: targetPath,
+			content_offset: 4n,
+			content_size_in_bytes: BigInt(blob.byteLength)
+		};
+		return {
+			specId: info.partitionSpecId,
+			partition: info.partition,
+			deleteFile
+		};
+	}));
+	const bySpec = /* @__PURE__ */ new Map();
+	for (const f of writtenDeleteFiles) {
+		let bucket = bySpec.get(f.specId);
+		if (!bucket) {
+			const spec = metadata["partition-specs"].find((s) => s["spec-id"] === f.specId);
+			if (!spec) throw new Error(`partition spec ${f.specId} not found in metadata`);
+			bucket = {
+				spec,
+				files: [],
+				partitions: []
+			};
+			bySpec.set(f.specId, bucket);
+		}
+		bucket.files.push(f.deleteFile);
+		bucket.partitions.push(f.partition);
+	}
+	const newManifests = [];
+	const writtenManifestPaths = [];
+	let manifestIndex = 0;
+	for (const { spec, files, partitions } of bySpec.values()) {
+		const manifestPath = `${tableUrl}/metadata/${manifestUuid}-m${manifestIndex}.avro`;
+		const manifestWriter = writerFn(manifestPath);
+		await writeDeleteManifest({
+			writer: manifestWriter,
+			schema,
+			partitionSpec: spec,
+			snapshotId,
+			deleteFiles: files,
+			formatVersion
+		});
+		const manifestLength = BigInt(manifestWriter.offset);
+		const totalAddedRows = files.reduce((sum, f) => sum + f.record_count, 0n);
+		newManifests.push({
+			manifest_path: manifestPath,
+			manifest_length: manifestLength,
+			partition_spec_id: spec["spec-id"],
+			content: 1,
+			sequence_number: sequenceNumber,
+			min_sequence_number: sequenceNumber,
+			added_snapshot_id: snapshotId,
+			added_files_count: files.length,
+			existing_files_count: 0,
+			deleted_files_count: 0,
+			added_rows_count: totalAddedRows,
+			existing_rows_count: 0n,
+			deleted_rows_count: 0n,
+			partitions: spec.fields.length ? buildPartitionSummaries(partitions, schema, spec) : []
+		});
+		writtenManifestPaths.push(manifestPath);
+		manifestIndex++;
+	}
+	const partitionKeys = /* @__PURE__ */ new Set();
+	for (const f of writtenDeleteFiles) partitionKeys.add(`${f.specId}|${partitionTupleKey(f.partition)}`);
+	const totalAddedRows = writtenDeleteFiles.reduce((sum, f) => sum + f.deleteFile.record_count, 0n);
+	const totalAddedSize = writtenDeleteFiles.reduce((sum, f) => sum + f.deleteFile.file_size_in_bytes, 0n);
+	const prevSummary = currentSnapshot(metadata)?.summary;
+	const prevTotals = {
+		records: BigInt(prevSummary?.["total-records"] ?? "0"),
+		size: BigInt(prevSummary?.["total-files-size"] ?? "0"),
+		dataFiles: BigInt(prevSummary?.["total-data-files"] ?? "0"),
+		deleteFiles: BigInt(prevSummary?.["total-delete-files"] ?? "0"),
+		posDeletes: BigInt(prevSummary?.["total-position-deletes"] ?? "0"),
+		eqDeletes: BigInt(prevSummary?.["total-equality-deletes"] ?? "0")
+	};
+	const summary = {
+		operation: "delete",
+		"added-delete-files": String(writtenDeleteFiles.length),
+		"added-dvs": String(writtenDeleteFiles.length),
+		"added-position-deletes": String(totalAddedRows),
+		"added-files-size": String(totalAddedSize),
+		"changed-partition-count": String(partitionKeys.size),
+		"total-records": String(prevTotals.records),
+		"total-files-size": String(prevTotals.size + totalAddedSize),
+		"total-data-files": String(prevTotals.dataFiles),
+		"total-delete-files": String(prevTotals.deleteFiles + BigInt(writtenDeleteFiles.length) - removedDeleteFiles),
+		"total-position-deletes": String(prevTotals.posDeletes + totalAddedRows - removedPositionDeletes),
+		"total-equality-deletes": String(prevTotals.eqDeletes)
+	};
+	if (removedDeleteFiles > 0n) {
+		summary["removed-delete-files"] = String(removedDeleteFiles);
+		summary["removed-position-deletes"] = String(removedPositionDeletes);
+		if (removedDvs > 0n) summary["removed-dvs"] = String(removedDvs);
+	}
+	return await buildSnapshotUpdate({
+		tableUrl,
+		metadata,
+		resolver,
+		snapshotId,
+		sequenceNumber,
+		manifestUuid,
+		timestampMs,
+		formatVersion,
+		newManifests: [...replacementManifests, ...newManifests],
+		summary,
+		writtenFiles: [
+			...replacementManifestPaths,
+			...writtenPuffinPaths,
+			...writtenManifestPaths
+		],
+		priorManifests,
+		skipPriorManifestPaths
+	});
+}
+async function loadPriorDeleteManifestEntries(manifests, resolver) {
+	return (await Promise.all(manifests.map(async (manifest) => {
+		if (manifest.content !== 1) return;
+		return {
+			manifest,
+			entries: await loadManifestEntries(manifest, resolver)
+		};
+	}))).filter((g) => g !== void 0);
+}
+function isDeletionVectorForTarget(entry, targetPaths) {
+	return entry.data_file.content === 1 && entry.data_file.file_format.toLowerCase() === "puffin" && entry.data_file.referenced_data_file !== void 0 && targetPaths.has(entry.data_file.referenced_data_file);
+}
+function isObsoleteDeleteEntry(entry, targetPaths, obsoletePositionDeleteEntries) {
+	return isDeletionVectorForTarget(entry, targetPaths) || obsoletePositionDeleteEntries.has(entry);
+}
+function minEntrySequenceNumber(entries, fallback) {
+	let min = fallback;
+	for (const entry of entries) if (entry.sequence_number !== void 0 && entry.sequence_number < min) min = entry.sequence_number;
+	return min;
+}
+export { icebergStageDeletionVector };

package/dist/_virtual/node_modules/.pnpm/icebird@0.8.15_patch_hash=d1902372376af18885e7c7dce807f1ecab86c2f86a9d1ff65d51e3b63b64b057/node_modules/icebird/src/write/stage-position-delete.mjs

@@ -0,0 +1,216 @@
+import { bytesToHex, uuid4 } from "../utils.mjs";
+import { fetchAvroRecords } from "../fetch.mjs";
+import { validateSchemaForVersion } from "../schema.mjs";
+import { writeDeleteManifest } from "./manifest.mjs";
+import { buildPartitionSummaries, buildSnapshotUpdate, currentSnapshot } from "./snapshot.mjs";
+import { checkWriteFormat, newSnapshotId, resolveParquetCodec } from "./stage.mjs";
+import { writePositionDeleteFile } from "./delete-file.mjs";
+async function icebergStagePositionDelete({ tableUrl, metadata, deletes, resolver }) {
+	if (!tableUrl) throw new Error("tableUrl is required");
+	if (!resolver?.writer) throw new Error("resolver.writer is required");
+	if (!Array.isArray(deletes) || !deletes.length) throw new Error("deletes must be a non-empty array");
+	const writerFn = resolver.writer;
+	if (metadata["format-version"] !== 2 && metadata["format-version"] !== 3) throw new Error(`unsupported format-version: ${metadata["format-version"]}`);
+	if (metadata["format-version"] === 3) throw new Error("format-version 3 tables must use deletion vectors, not new position delete files");
+	const formatVersion = metadata["format-version"];
+	if (!metadata["partition-specs"].find((s) => s["spec-id"] === metadata["default-spec-id"])) throw new Error("default partition spec not found in metadata");
+	const schema = metadata.schemas.find((s) => s["schema-id"] === metadata["current-schema-id"]);
+	if (!schema) throw new Error("current schema not found in metadata");
+	validateSchemaForVersion(schema, formatVersion);
+	const snapshotId = newSnapshotId();
+	const sequenceNumber = BigInt(metadata["last-sequence-number"] ?? 0) + 1n;
+	const manifestUuid = uuid4();
+	const timestampMs = Date.now();
+	checkWriteFormat(metadata.properties?.["write.format.default"]);
+	const codec = resolveParquetCodec(metadata.properties?.["write.parquet.compression-codec"]);
+	const partitionMap = await findDataFilePartitions(metadata, resolver);
+	const groups = /* @__PURE__ */ new Map();
+	for (const d of deletes) {
+		const found = partitionMap.get(d.file_path);
+		if (!found) throw new Error(`target data file not found in current snapshot: ${d.file_path}`);
+		const { partition, partitionSpecId: specId } = found;
+		const key = `${specId}|${partitionTupleKey(partition)}`;
+		let group = groups.get(key);
+		if (!group) {
+			group = {
+				specId,
+				partition,
+				deletes: []
+			};
+			groups.set(key, group);
+		}
+		group.deletes.push(d);
+	}
+	const writtenDeleteFiles = await Promise.all([...groups.values()].map(async (group) => {
+		const referencedDataFile = new Set(group.deletes.map((d) => d.file_path)).size === 1 ? group.deletes[0].file_path : void 0;
+		const deletePath = `${tableUrl}/data/${uuid4()}-deletes.parquet`;
+		const deleteWriter = writerFn(deletePath);
+		const stats = await writePositionDeleteFile({
+			writer: deleteWriter,
+			deletes: group.deletes,
+			codec
+		});
+		const deleteFile = {
+			content: 1,
+			file_path: deletePath,
+			file_format: "parquet",
+			partition: group.partition,
+			record_count: stats.record_count,
+			file_size_in_bytes: BigInt(deleteWriter.offset),
+			value_counts: stats.value_counts,
+			null_value_counts: stats.null_value_counts,
+			lower_bounds: stats.lower_bounds,
+			upper_bounds: stats.upper_bounds,
+			sort_order_id: 0,
+			referenced_data_file: referencedDataFile
+		};
+		return {
+			specId: group.specId,
+			partition: group.partition,
+			deleteFile,
+			path: deletePath
+		};
+	}));
+	const bySpec = /* @__PURE__ */ new Map();
+	for (const f of writtenDeleteFiles) {
+		let bucket = bySpec.get(f.specId);
+		if (!bucket) {
+			const spec = metadata["partition-specs"].find((s) => s["spec-id"] === f.specId);
+			if (!spec) throw new Error(`partition spec ${f.specId} not found in metadata`);
+			bucket = {
+				spec,
+				files: [],
+				partitions: []
+			};
+			bySpec.set(f.specId, bucket);
+		}
+		bucket.files.push(f.deleteFile);
+		bucket.partitions.push(f.partition);
+	}
+	const newManifests = [];
+	const writtenManifestPaths = [];
+	let manifestIndex = 0;
+	for (const { spec, files, partitions } of bySpec.values()) {
+		const manifestPath = `${tableUrl}/metadata/${manifestUuid}-m${manifestIndex}.avro`;
+		const manifestWriter = writerFn(manifestPath);
+		await writeDeleteManifest({
+			writer: manifestWriter,
+			schema,
+			partitionSpec: spec,
+			snapshotId,
+			deleteFiles: files,
+			formatVersion
+		});
+		const manifestLength = BigInt(manifestWriter.offset);
+		const totalAddedRows = files.reduce((sum, f) => sum + f.record_count, 0n);
+		newManifests.push({
+			manifest_path: manifestPath,
+			manifest_length: manifestLength,
+			partition_spec_id: spec["spec-id"],
+			content: 1,
+			sequence_number: sequenceNumber,
+			min_sequence_number: sequenceNumber,
+			added_snapshot_id: snapshotId,
+			added_files_count: files.length,
+			existing_files_count: 0,
+			deleted_files_count: 0,
+			added_rows_count: totalAddedRows,
+			existing_rows_count: 0n,
+			deleted_rows_count: 0n,
+			partitions: spec.fields.length ? buildPartitionSummaries(partitions, schema, spec) : []
+		});
+		writtenManifestPaths.push(manifestPath);
+		manifestIndex++;
+	}
+	const prevSummary = currentSnapshot(metadata)?.summary;
+	const prevTotals = {
+		records: BigInt(prevSummary?.["total-records"] ?? "0"),
+		size: BigInt(prevSummary?.["total-files-size"] ?? "0"),
+		dataFiles: BigInt(prevSummary?.["total-data-files"] ?? "0"),
+		deleteFiles: BigInt(prevSummary?.["total-delete-files"] ?? "0"),
+		posDeletes: BigInt(prevSummary?.["total-position-deletes"] ?? "0"),
+		eqDeletes: BigInt(prevSummary?.["total-equality-deletes"] ?? "0")
+	};
+	const addedSize = writtenDeleteFiles.reduce((sum, f) => sum + f.deleteFile.file_size_in_bytes, 0n);
+	const addedPosDeletes = writtenDeleteFiles.reduce((sum, f) => sum + f.deleteFile.record_count, 0n);
+	return await buildSnapshotUpdate({
+		tableUrl,
+		metadata,
+		resolver,
+		snapshotId,
+		sequenceNumber,
+		manifestUuid,
+		timestampMs,
+		formatVersion,
+		newManifests,
+		summary: {
+			operation: "delete",
+			"added-delete-files": String(writtenDeleteFiles.length),
+			"added-position-deletes": String(addedPosDeletes),
+			"added-files-size": String(addedSize),
+			"changed-partition-count": String(groups.size),
+			"total-records": String(prevTotals.records),
+			"total-files-size": String(prevTotals.size + addedSize),
+			"total-data-files": String(prevTotals.dataFiles),
+			"total-delete-files": String(prevTotals.deleteFiles + BigInt(writtenDeleteFiles.length)),
+			"total-position-deletes": String(prevTotals.posDeletes + addedPosDeletes),
+			"total-equality-deletes": String(prevTotals.eqDeletes)
+		},
+		writtenFiles: [...writtenDeleteFiles.map((f) => f.path), ...writtenManifestPaths]
+	});
+}
+async function loadManifestEntries(manifest, resolver) {
+	const entries = await fetchAvroRecords(manifest.manifest_path, resolver, Number(manifest.manifest_length));
+	for (const entry of entries) {
+		entry.partition_spec_id = manifest.partition_spec_id ?? 0;
+		if (entry.sequence_number === void 0) entry.sequence_number = manifest.sequence_number ?? 0n;
+		if (entry.status === 1 && entry.file_sequence_number === void 0) entry.file_sequence_number = manifest.sequence_number ?? 0n;
+	}
+	return entries;
+}
+async function findDataFilePartitions(metadata, resolver) {
+	const entries = await findDataFileEntries(metadata, resolver);
+	const out = /* @__PURE__ */ new Map();
+	for (const [path, found] of entries) out.set(path, {
+		partition: found.partition,
+		partitionSpecId: found.partitionSpecId
+	});
+	return out;
+}
+async function findDataFileEntries(metadata, resolver) {
+	const snap = currentSnapshot(metadata);
+	if (!snap?.["manifest-list"]) return /* @__PURE__ */ new Map();
+	const manifests = await fetchAvroRecords(snap["manifest-list"], resolver);
+	const out = /* @__PURE__ */ new Map();
+	await Promise.all(manifests.map(async (manifest) => {
+		if (manifest.content !== 0) return;
+		const entries = await loadManifestEntries(manifest, resolver);
+		for (const entry of entries) {
+			if (entry.status === 2) continue;
+			const f = entry.data_file;
+			if (f.content !== 0) continue;
+			out.set(f.file_path, {
+				partition: f.partition ?? {},
+				partitionSpecId: manifest.partition_spec_id ?? 0,
+				entry
+			});
+		}
+	}));
+	return out;
+}
+function partitionTupleKey(partition) {
+	return Object.keys(partition).sort().map((k) => `${k}=${valueTag(partition[k])}`).join(",");
+}
+function valueTag(v) {
+	if (v === null || v === void 0) return "null";
+	if (typeof v === "bigint") return `b:${v.toString()}`;
+	if (typeof v === "number") {
+		if (Number.isNaN(v)) return "n:NaN";
+		if (Object.is(v, -0)) return "n:-0";
+		return `n:${v}`;
+	}
+	if (v instanceof Date) return `d:${v.getTime()}`;
+	if (v instanceof Uint8Array) return `x:${bytesToHex(v)}`;
+	return `${typeof v}:${String(v)}`;
+}
+export { findDataFileEntries, icebergStagePositionDelete, loadManifestEntries, partitionTupleKey };