@gscdump/cloudflare 1.4.0 → 1.4.2

package/dist/index.mjs

@@ -1,476 +1,4 @@
-import { coerceRow, createStorageEngine } from "@gscdump/engine";
-import { createD1ManifestStore } from "@gscdump/engine-sqlite";
-import { createR2DataSource } from "@gscdump/engine/r2";
-import { createHyparquetCodec, decodeParquetToRows } from "@gscdump/engine/hyparquet";
-import { SCHEMAS } from "@gscdump/engine/schema";
-import { bindLiterals } from "@gscdump/engine/sql";
-import { float64, int32, int64, tableFromArrays, tableToIPC, utf8 } from "@uwdata/flechette";
-function arrowTypeForColumn(type) {
-	switch (type) {
-		case "VARCHAR":
-		case "DATE": return utf8();
-		case "BIGINT": return int64();
-		case "INTEGER": return int32();
-		case "DOUBLE": return float64();
-	}
-}
-function rowsToArrowIPC(rows, schemaColumns) {
-	const colNames = [];
-	const seen = /* @__PURE__ */ new Set();
-	const add = (name) => {
-		if (!seen.has(name)) {
-			seen.add(name);
-			colNames.push(name);
-		}
-	};
-	if (schemaColumns) for (const c of schemaColumns) add(c.name);
-	for (const row of rows) for (const key in row) add(key);
-	const schemaType = /* @__PURE__ */ new Map();
-	if (schemaColumns) for (const c of schemaColumns) schemaType.set(c.name, c.type);
-	const data = {};
-	const types = {};
-	for (const name of colNames) {
-		const values = rows.map((r) => r[name] ?? null);
-		data[name] = values;
-		const known = schemaType.get(name);
-		if (known) {
-			types[name] = arrowTypeForColumn(known);
-			continue;
-		}
-		let hasString = false;
-		let hasValue = false;
-		for (const v of values) {
-			if (v === null || v === void 0) continue;
-			hasValue = true;
-			if (typeof v === "string") {
-				hasString = true;
-				break;
-			}
-		}
-		if (hasString || !hasValue) types[name] = utf8();
-	}
-	const ipc = tableToIPC(tableFromArrays(data, { types }), { format: "stream" });
-	if (!ipc) throw new Error("rowsToArrowIPC: tableToIPC returned null");
-	return ipc;
-}
-function resolveSvc(env) {
-	const svc = env.DUCKDB_SVC;
-	if (!svc) throw new Error("DUCKDB_SVC service binding is not configured");
-	return svc;
-}
-const DUCKDB_RPC_TIMEOUT_MS = 22e3;
-const WORKER_R2_MAX_FILES = 96;
-const WORKER_R2_MAX_BYTES = 64 * 1024 * 1024;
-const WORKER_R2_DECODE_CONCURRENCY = 2;
-const WORKER_R2_HEAD_CONCURRENCY = 4;
-const IPC_CHUNK_BUDGET = 8 * 1024 * 1024;
-const IPC_DIRECT_CALL_BUDGET = 30 * 1024 * 1024;
-const IPC_STAGED_TOTAL_BUDGET = 64 * 1024 * 1024;
-var DuckDBServiceTimeoutError = class extends Error {
-	name = "DuckDBServiceTimeoutError";
-	constructor(timeoutMs) {
-		super(`DUCKDB_SVC.runSQL exceeded ${timeoutMs}ms deadline`);
-	}
-};
-function withDuckDBDeadline(op, timeoutMs, signal) {
-	if (signal?.aborted) return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
-	return new Promise((resolve, reject) => {
-		let settled = false;
-		let timer;
-		let onAbort;
-		const cleanup = () => {
-			if (timer !== void 0) clearTimeout(timer);
-			if (onAbort) signal?.removeEventListener("abort", onAbort);
-		};
-		const settle = (complete, value) => {
-			if (settled) return;
-			settled = true;
-			cleanup();
-			complete(value);
-		};
-		onAbort = () => settle(reject, signal.reason ?? new DOMException("Aborted", "AbortError"));
-		timer = setTimeout(() => settle(reject, new DuckDBServiceTimeoutError(timeoutMs)), timeoutMs);
-		signal?.addEventListener("abort", onAbort, { once: true });
-		op.then((value) => settle(resolve, value), (error) => settle(reject, error));
-	});
-}
-function runSQLWithDeadline(svc, args, timeoutMs, signal) {
-	const deadlineAt = Date.now() + timeoutMs;
-	return withDuckDBDeadline(svc.runSQL({
-		...args,
-		deadlineAt
-	}), timeoutMs, signal);
-}
-function createDucklingsCodec(_env) {
-	return createHyparquetCodec();
-}
-const READ_PARQUET_PLACEHOLDER = /read_parquet\(\{\{(\w+)\}\}(?:\s*,[^)]*)?\)/g;
-function tmpTableName(placeholder) {
-	const uuid = crypto.randomUUID().replace(/-/g, "_");
-	return `tmp_${placeholder.toLowerCase()}_${uuid}`;
-}
-async function mapLimit(items, concurrency, fn) {
-	const limit = Math.max(1, Math.floor(concurrency));
-	const out = Array.from({ length: items.length });
-	let next = 0;
-	let failed = false;
-	let failure;
-	async function worker() {
-		while (!failed && next < items.length) {
-			const index = next++;
-			try {
-				out[index] = await fn(items[index], index);
-			} catch (error) {
-				failed = true;
-				failure = error;
-			}
-		}
-	}
-	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
-	if (failed) throw failure;
-	return out;
-}
-function assertWorkerReadBudget(opts) {
-	const maxFiles = opts.maxFiles ?? WORKER_R2_MAX_FILES;
-	const maxBytes = opts.maxBytes ?? WORKER_R2_MAX_BYTES;
-	const entries = Object.entries(opts.fileKeys);
-	const totalFiles = entries.reduce((acc, [, keys]) => acc + keys.length, 0);
-	if (totalFiles > maxFiles) throw new Error(`createDucklingsExecutor: planned read spans ${totalFiles} files, exceeding the ${maxFiles} file Worker budget. Narrow the date range or route through a background/windowed query.`);
-	if (!opts.sizes) return;
-	let totalBytes = 0;
-	for (const [, keys] of entries) for (const key of keys) {
-		const bytes = opts.sizes[key];
-		if (bytes !== void 0) totalBytes += Math.max(0, bytes);
-	}
-	if (totalBytes > maxBytes) throw new Error(`createDucklingsExecutor: planned read spans ${totalBytes} bytes, exceeding the ${maxBytes} byte Worker budget. Narrow the date range or route through a background/windowed query.`);
-}
-const ROW_CACHE_MAX_BYTES = 16 * 1024 * 1024;
-function estimateRowsBytes(rows) {
-	if (rows.length === 0) return 0;
-	const cols = Object.keys(rows[0]).length;
-	return rows.length * cols * 64;
-}
-function addInferredValue(inference, value) {
-	if (value === null || value === void 0) return;
-	inference.hasValue = true;
-	if (typeof value === "string") {
-		inference.hasString = true;
-		return;
-	}
-	if (typeof value === "bigint") {
-		inference.hasBigInt = true;
-		return;
-	}
-	if (typeof value === "number") {
-		if (!Number.isInteger(value)) inference.hasFloat = true;
-		if (value > 2147483647 || value < -2147483648) inference.hasBigInt = true;
-	}
-}
-function inferredColumnType(inference) {
-	if (!inference.hasValue || inference.hasString) return "VARCHAR";
-	if (inference.hasFloat) return "DOUBLE";
-	return inference.hasBigInt ? "BIGINT" : "INTEGER";
-}
-function chunkSchemaColumns(rows, schemaColumns) {
-	const columns = schemaColumns ? [...schemaColumns] : [];
-	const seen = new Set(columns.map((c) => c.name));
-	const extraColumns = /* @__PURE__ */ new Map();
-	for (const row of rows) for (const key in row) {
-		if (seen.has(key)) continue;
-		let inference = extraColumns.get(key);
-		if (!inference) {
-			inference = {
-				hasValue: false,
-				hasString: false,
-				hasFloat: false,
-				hasBigInt: false
-			};
-			extraColumns.set(key, inference);
-		}
-		addInferredValue(inference, row[key]);
-	}
-	if (extraColumns.size === 0) return schemaColumns ? columns : void 0;
-	for (const [name, inference] of extraColumns) columns.push({
-		name,
-		type: inferredColumnType(inference),
-		nullable: true
-	});
-	return columns;
-}
-function rowsToArrowIPCChunks(rows, schemaColumns, opts = {}) {
-	const maxChunkBytes = Math.max(1, Math.floor(opts.maxChunkBytes ?? IPC_CHUNK_BUDGET));
-	const placeholder = opts.placeholder ? `{{${opts.placeholder}}}` : "placeholder";
-	const chunkColumns = chunkSchemaColumns(rows, schemaColumns);
-	if (rows.length === 0) {
-		const ipc = rowsToArrowIPC([], chunkColumns);
-		if (ipc.byteLength > maxChunkBytes) throw new Error(`createDucklingsExecutor: empty ${placeholder} Arrow IPC schema encoded to ${ipc.byteLength} bytes, exceeding the ${maxChunkBytes}-byte service-binding chunk budget.`);
-		return [{
-			ipc,
-			rows: 0
-		}];
-	}
-	const estimatedPerRow = Math.max(1, Math.ceil(estimateRowsBytes(rows) / rows.length));
-	let targetRows = Math.max(1, Math.min(rows.length, Math.floor(maxChunkBytes * .75 / estimatedPerRow)));
-	const chunks = [];
-	let index = 0;
-	while (index < rows.length) {
-		let take = Math.min(targetRows, rows.length - index);
-		while (true) {
-			const slice = rows.slice(index, index + take);
-			const ipc = rowsToArrowIPC(slice, chunkColumns);
-			if (ipc.byteLength <= maxChunkBytes) {
-				chunks.push({
-					ipc,
-					rows: slice.length
-				});
-				index += take;
-				if (ipc.byteLength < maxChunkBytes * .4 && take === targetRows) targetRows = Math.min(rows.length - index || targetRows, targetRows * 2);
-				break;
-			}
-			if (take === 1) throw new Error(`createDucklingsExecutor: one ${placeholder} row encoded to ${ipc.byteLength} bytes of Arrow IPC, exceeding the ${maxChunkBytes}-byte service-binding chunk budget. Narrow the query or route through a background/windowed query.`);
-			take = Math.max(1, Math.floor(take / 2));
-		}
-	}
-	return chunks;
-}
-function createDucklingsRowCache(maxBytes = ROW_CACHE_MAX_BYTES) {
-	let totalBytes = 0;
-	const entries = /* @__PURE__ */ new Map();
-	return {
-		clear() {
-			entries.clear();
-			totalBytes = 0;
-		},
-		get(key) {
-			const hit = entries.get(key);
-			if (!hit) return void 0;
-			entries.delete(key);
-			entries.set(key, hit);
-			return hit.rows;
-		},
-		put(key, rows) {
-			const bytes = estimateRowsBytes(rows);
-			if (bytes > maxBytes) return;
-			const existing = entries.get(key);
-			if (existing) {
-				entries.delete(key);
-				totalBytes -= existing.bytes;
-			}
-			while (totalBytes + bytes > maxBytes) {
-				const oldest = entries.keys().next().value;
-				if (oldest === void 0) break;
-				const evicted = entries.get(oldest);
-				entries.delete(oldest);
-				totalBytes -= evicted.bytes;
-			}
-			entries.set(key, {
-				rows,
-				bytes
-			});
-			totalBytes += bytes;
-		}
-	};
-}
-function createDucklingsExecutor(env, opts = {}) {
-	const rowCache = opts.rowCache ?? createDucklingsRowCache();
-	const rpcTimeoutMs = opts.rpcTimeoutMs ?? DUCKDB_RPC_TIMEOUT_MS;
-	if (!Number.isFinite(rpcTimeoutMs) || rpcTimeoutMs <= 0) throw new TypeError("createDucklingsExecutor: rpcTimeoutMs must be a positive finite number");
-	return { async execute({ sql, params, fileKeys, placeholderTables, pushdownFilters, dataSource, signal, table }) {
-		signal?.throwIfAborted();
-		const svc = resolveSvc(env);
-		assertWorkerReadBudget({ fileKeys });
-		const cachedUnfiltered = /* @__PURE__ */ new Map();
-		const scheduledUnfiltered = /* @__PURE__ */ new Set();
-		const plannedReadKeys = [];
-		for (const [placeholder, keys] of Object.entries(fileKeys)) {
-			const filter = pushdownFilters?.[placeholder];
-			for (const key of keys) {
-				if (filter) {
-					plannedReadKeys.push(key);
-					continue;
-				}
-				const cached = cachedUnfiltered.get(key) ?? rowCache.get(key);
-				if (cached !== void 0) {
-					cachedUnfiltered.set(key, cached);
-					continue;
-				}
-				if (!scheduledUnfiltered.has(key)) {
-					scheduledUnfiltered.add(key);
-					plannedReadKeys.push(key);
-				}
-			}
-		}
-		if (dataSource.head && plannedReadKeys.length > 0) {
-			const uniqueKeys = [...new Set(plannedReadKeys)];
-			const sizes = {};
-			await mapLimit(uniqueKeys, WORKER_R2_HEAD_CONCURRENCY, async (key) => {
-				signal?.throwIfAborted();
-				sizes[key] = (await dataSource.head(key))?.bytes;
-			});
-			assertWorkerReadBudget({
-				fileKeys: { READS: plannedReadKeys },
-				sizes
-			});
-		}
-		const tempNames = {};
-		const tableChunks = {};
-		let totalIpcBytes = 0;
-		const maxChunkBytes = opts.ipcChunkBytes ?? IPC_CHUNK_BUDGET;
-		const maxDirectCallBytes = opts.ipcDirectCallBytes ?? IPC_DIRECT_CALL_BUDGET;
-		const maxTotalBytes = opts.ipcTotalBytes ?? IPC_STAGED_TOTAL_BUDGET;
-		const unfilteredLoads = /* @__PURE__ */ new Map();
-		for (const [key, rows] of cachedUnfiltered) unfilteredLoads.set(key, Promise.resolve(rows));
-		const loadUnfiltered = (key) => {
-			let loading = unfilteredLoads.get(key);
-			if (!loading) {
-				loading = (async () => {
-					signal?.throwIfAborted();
-					const bytes = await dataSource.read(key, void 0, signal);
-					signal?.throwIfAborted();
-					const rows = await decodeParquetToRows(bytes);
-					rowCache.put(key, rows);
-					return rows;
-				})();
-				unfilteredLoads.set(key, loading);
-			}
-			return loading;
-		};
-		for (const [placeholder, keys] of Object.entries(fileKeys)) {
-			signal?.throwIfAborted();
-			const filter = pushdownFilters?.[placeholder];
-			const perFile = await mapLimit(keys, WORKER_R2_DECODE_CONCURRENCY, async (key) => {
-				if (!filter) return loadUnfiltered(key);
-				signal?.throwIfAborted();
-				const bytes = await dataSource.read(key, void 0, signal);
-				signal?.throwIfAborted();
-				return await decodeParquetToRows(bytes, filter ? { filter } : {});
-			});
-			const merged = [];
-			for (const rows of perFile) merged.push(...rows);
-			const chunks = rowsToArrowIPCChunks(merged, SCHEMAS[placeholderTables?.[placeholder] ?? table]?.columns, {
-				maxChunkBytes,
-				placeholder
-			});
-			signal?.throwIfAborted();
-			totalIpcBytes += chunks.reduce((acc, chunk) => acc + chunk.ipc.byteLength, 0);
-			if (totalIpcBytes > maxTotalBytes) throw new Error(`createDucklingsExecutor: query encoded to ${totalIpcBytes} bytes of Arrow IPC across ${Object.keys(tableChunks).length + 1} placeholders, exceeding the ${maxTotalBytes}-byte service-binding transport budget. Window the query (chunk partitions / narrow the range).`);
-			const tmp = tmpTableName(placeholder);
-			tempNames[placeholder] = tmp;
-			tableChunks[tmp] = chunks;
-		}
-		signal?.throwIfAborted();
-		const finalSql = bindLiterals(sql.replace(READ_PARQUET_PLACEHOLDER, (_, placeholder) => {
-			const tmp = tempNames[placeholder];
-			if (!tmp) throw new Error(`createDucklingsExecutor: SQL references {{${placeholder}}} but no fileKeys entry provided`);
-			return tmp;
-		}), params);
-		const canInlineTables = totalIpcBytes <= maxDirectCallBytes && Object.values(tableChunks).every((chunks) => chunks.length === 1);
-		let result;
-		if (canInlineTables) {
-			const tables = {};
-			for (const [name, chunks] of Object.entries(tableChunks)) tables[name] = { ipc: chunks[0].ipc };
-			result = await runSQLWithDeadline(svc, {
-				sql: finalSql,
-				tables
-			}, rpcTimeoutMs, signal);
-		} else {
-			if (!svc.stageArrowTable || !svc.dropTables) throw new Error("createDucklingsExecutor: DUCKDB_SVC does not support chunked Arrow IPC staging. Deploy the gscdump-duckdb worker with stageArrowTable/dropTables support.");
-			const staged = /* @__PURE__ */ new Set();
-			let primaryError;
-			let cleanupError;
-			try {
-				for (const [name, chunks] of Object.entries(tableChunks)) for (const chunk of chunks) {
-					signal?.throwIfAborted();
-					staged.add(name);
-					await withDuckDBDeadline(svc.stageArrowTable({
-						table: name,
-						ipc: chunk.ipc
-					}), rpcTimeoutMs, signal);
-				}
-				result = await runSQLWithDeadline(svc, { sql: finalSql }, rpcTimeoutMs, signal);
-			} catch (error) {
-				primaryError = error;
-			} finally {
-				if (staged.size > 0) try {
-					await withDuckDBDeadline(svc.dropTables({ tables: [...staged] }), rpcTimeoutMs);
-				} catch (error) {
-					cleanupError = error;
-				}
-			}
-			if (primaryError) throw primaryError;
-			if (cleanupError) throw cleanupError;
-			result = result;
-		}
-		return {
-			rows: result.rows.map(coerceRow),
-			sql: result.sql
-		};
-	} };
-}
-function createAnalyticsEngineRuntime() {
-	const rowCache = createDucklingsRowCache();
-	return { getEngine(env, db, hooks = {}) {
-		if (!env.R2_DATA) return null;
-		const baseDataSource = createR2DataSource({
-			bucket: env.R2_DATA,
-			bucketName: env.R2_BUCKET_NAME
-		});
-		return createStorageEngine({
-			dataSource: hooks.onR2Write ? {
-				...baseDataSource,
-				async write(key, bytes) {
-					hooks.onR2Write(bytes.byteLength);
-					return baseDataSource.write(key, bytes);
-				}
-			} : baseDataSource,
-			manifestStore: createD1ManifestStore(db),
-			codec: createDucklingsCodec(env),
-			executor: createDucklingsExecutor(env, {
-				rowCache,
-				...hooks.duckdbRpcTimeoutMs !== void 0 ? { rpcTimeoutMs: hooks.duckdbRpcTimeoutMs } : {}
-			})
-		});
-	} };
-}
-let sharedRuntime;
-function getAnalyticsEngine(env, db, hooks = {}) {
-	sharedRuntime ??= createAnalyticsEngineRuntime();
-	return sharedRuntime.getEngine(env, db, hooks);
-}
-function createInflightDedupe() {
-	const inflight = /* @__PURE__ */ new Map();
-	return {
-		dedupe(key, run) {
-			const existing = inflight.get(key);
-			if (existing) return existing;
-			const promise = run().finally(() => {
-				if (inflight.get(key) === promise) inflight.delete(key);
-			});
-			inflight.set(key, promise);
-			return promise;
-		},
-		has(key) {
-			return inflight.has(key);
-		},
-		clear() {
-			inflight.clear();
-		}
-	};
-}
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	if (value && typeof value === "object") return `{${Object.keys(value).sort().map((key) => {
-		return `${JSON.stringify(key)}:${stableStringify(value[key])}`;
-	}).join(",")}}`;
-	return JSON.stringify(value);
-}
-function getHostedR2QueryKey(input) {
-	return JSON.stringify([
-		input.userId,
-		input.siteId,
-		stableStringify(input.state),
-		input.comparison === void 0 ? null : stableStringify(input.comparison),
-		input.comparisonFilter ?? null
-	]);
-}
+import { createDucklingsCodec, createDucklingsExecutor, createDucklingsRowCache } from "./workers-duckdb.mjs";
+import { getAnalyticsEngine } from "./engine.mjs";
+import { createInflightDedupe, getHostedR2QueryKey } from "./inflight-dedupe.mjs";
 export { createDucklingsCodec, createDucklingsExecutor, createDucklingsRowCache, createInflightDedupe, getAnalyticsEngine, getHostedR2QueryKey };

package/dist/inflight-dedupe.d.mts

@@ -0,0 +1,15 @@
+interface InflightDedupe<T> {
+  dedupe: (key: string, run: () => Promise<T>) => Promise<T>;
+  has: (key: string) => boolean;
+  clear: () => void;
+}
+declare function createInflightDedupe<T>(): InflightDedupe<T>;
+interface HostedR2QueryKeyInput {
+  userId: string | number;
+  siteId: string;
+  state: unknown;
+  comparison?: unknown;
+  comparisonFilter?: string;
+}
+declare function getHostedR2QueryKey(input: HostedR2QueryKeyInput): string;
+export { HostedR2QueryKeyInput, InflightDedupe, createInflightDedupe, getHostedR2QueryKey };

package/dist/inflight-dedupe.mjs

@@ -0,0 +1,37 @@
+function createInflightDedupe() {
+	const inflight = /* @__PURE__ */ new Map();
+	return {
+		dedupe(key, run) {
+			const existing = inflight.get(key);
+			if (existing) return existing;
+			const promise = run().finally(() => {
+				if (inflight.get(key) === promise) inflight.delete(key);
+			});
+			inflight.set(key, promise);
+			return promise;
+		},
+		has(key) {
+			return inflight.has(key);
+		},
+		clear() {
+			inflight.clear();
+		}
+	};
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.keys(value).sort().map((key) => {
+		return `${JSON.stringify(key)}:${stableStringify(value[key])}`;
+	}).join(",")}}`;
+	return JSON.stringify(value);
+}
+function getHostedR2QueryKey(input) {
+	return JSON.stringify([
+		input.userId,
+		input.siteId,
+		stableStringify(input.state),
+		input.comparison === void 0 ? null : stableStringify(input.comparison),
+		input.comparisonFilter ?? null
+	]);
+}
+export { createInflightDedupe, getHostedR2QueryKey };

package/dist/server-tail/archetype-sql.d.mts

@@ -0,0 +1,38 @@
+import { ArchetypeQuery } from "@gscdump/contracts/archetypes";
+declare const TABLE_PLACEHOLDER = "{{TABLE}}";
+type ArchetypeFactTable = 'pages' | 'queries' | 'countries' | 'page_queries' | 'dates';
+interface ArchetypeSqlPlan {
+  sql: string;
+  params: unknown[];
+  table: ArchetypeFactTable;
+}
+type PartitionPredicateMode = 'bare' | 'r2-sql-concat';
+type PartitionKeyEncoding = 'int' | 'string';
+interface BuildArchetypeSqlOptions {
+  /**
+   * Set by the DuckDB file-list executor, which reads raw Iceberg parquet
+   * directly via `read_parquet([...])`, bypassing the catalog metadata layer
+   * that synthesizes the identity-partition columns. `site_id` / `search_type`
+   * are partition identities NOT materialized in the data files (see engine
+   * `iceberg/schema.ts`: "carried implicitly in the object-key prefix"), so a
+   * `WHERE site_id = ?` predicate fails with `Referenced column "site_id" not
+   * found in FROM clause`. Those files are already pruned to (site_id,
+   * search_type) at resolution time, so the predicate is redundant — emit only
+   * the row-level `date` range (a real stored column; `month(date)` is the
+   * partition transform, not `date` itself).
+   *
+   * The R2 SQL catalog path (default `false`) exposes partition columns as
+   * virtual columns and needs the full predicate.
+   */
+  partitionPruned?: boolean;
+  /**
+   * Int-partition catalogs are the default and use bare equality. Legacy
+   * string-partition catalogs can request CONCAT-wrapped predicates directly
+   * instead of post-processing generated SQL.
+   */
+  partitionPredicateMode?: PartitionPredicateMode;
+  /** Preferred input for new callers. Defaults to `'int'`. */
+  partitionKeyEncoding?: PartitionKeyEncoding;
+}
+declare function buildArchetypeSql(query: ArchetypeQuery, opts?: BuildArchetypeSqlOptions): ArchetypeSqlPlan;
+export { ArchetypeFactTable, ArchetypeSqlPlan, BuildArchetypeSqlOptions, PartitionKeyEncoding, PartitionPredicateMode, TABLE_PLACEHOLDER, buildArchetypeSql };