@gscdump/engine 1.4.0 → 1.4.1

package/dist/_chunks/resolver.mjs

@@ -1,1220 +0,0 @@
-import { SCHEMAS, drizzleSchema } from "./schema.mjs";
-import { enumeratePartitions } from "./parquet-plan.mjs";
-import { escapeLike } from "../sql-fragments.mjs";
-import "../planner.mjs";
-import { UnresolvableDatasetError, buildLogicalComparisonPlan, buildLogicalPlan, inferDataset as inferLogicalDataset, isDatasetResolvable } from "gscdump/query/plan";
-import { PgDialect, pgTable, varchar } from "drizzle-orm/pg-core";
-import { normalizeUrl } from "gscdump/normalize";
-import { DEFAULT_PARTITION_KEY_ENCODING } from "@gscdump/lakehouse/schema";
-import { sql } from "drizzle-orm";
-import { and as and$1, gte as gte$1, impressions } from "gscdump/query";
-const DIMENSION_SURFACES = {
-	page: ["api", "stored"],
-	query: ["api", "stored"],
-	queryCanonical: ["derived"],
-	country: ["api", "stored"],
-	device: ["api", "stored"],
-	searchAppearance: ["api", "stored"],
-	date: ["api", "stored"],
-	hour: ["api", "stored"]
-};
-const LOGICAL_DATASETS = {
-	pages: { dimensions: {
-		page: {
-			column: "url",
-			surfaces: ["api", "stored"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	queries: { dimensions: {
-		query: {
-			column: "query",
-			surfaces: ["api", "stored"]
-		},
-		queryCanonical: {
-			column: "query_canonical",
-			surfaces: ["derived"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	page_queries: { dimensions: {
-		page: {
-			column: "url",
-			surfaces: ["api", "stored"]
-		},
-		query: {
-			column: "query",
-			surfaces: ["api", "stored"]
-		},
-		queryCanonical: {
-			column: "query_canonical",
-			surfaces: ["derived"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	countries: { dimensions: {
-		country: {
-			column: "country",
-			surfaces: ["api", "stored"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	dates: { dimensions: { date: {
-		column: "date",
-		surfaces: ["api", "stored"]
-	} } },
-	search_appearance: { dimensions: {
-		searchAppearance: {
-			column: "searchAppearance",
-			surfaces: ["api", "stored"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	search_appearance_pages: { dimensions: {
-		searchAppearance: {
-			column: "searchAppearance",
-			surfaces: ["stored"]
-		},
-		page: {
-			column: "url",
-			surfaces: ["stored"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["stored"]
-		}
-	} },
-	search_appearance_queries: { dimensions: {
-		searchAppearance: {
-			column: "searchAppearance",
-			surfaces: ["stored"]
-		},
-		query: {
-			column: "query",
-			surfaces: ["stored"]
-		},
-		queryCanonical: {
-			column: "query_canonical",
-			surfaces: ["derived"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["stored"]
-		}
-	} },
-	search_appearance_page_queries: { dimensions: {
-		searchAppearance: {
-			column: "searchAppearance",
-			surfaces: ["stored"]
-		},
-		page: {
-			column: "url",
-			surfaces: ["stored"]
-		},
-		query: {
-			column: "query",
-			surfaces: ["stored"]
-		},
-		queryCanonical: {
-			column: "query_canonical",
-			surfaces: ["derived"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["stored"]
-		}
-	} },
-	hourly_pages: { dimensions: {
-		page: {
-			column: "url",
-			surfaces: ["api", "stored"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		},
-		hour: {
-			column: "hour",
-			surfaces: ["api", "stored"]
-		}
-	} }
-};
-function dimensionColumn(dim, dataset) {
-	return LOGICAL_DATASETS[dataset].dimensions[dim]?.column ?? dim;
-}
-function supportsDimensionOnSurface(dim, surface) {
-	return DIMENSION_SURFACES[dim].includes(surface);
-}
-function assertDimensionsSupported(dimensions, surface, context) {
-	const unsupported = dimensions.filter((dim) => !supportsDimensionOnSurface(dim, surface));
-	if (unsupported.length === 0) return;
-	throw new Error(`${context}: unsupported dimensions for ${surface}: ${unsupported.join(", ")}`);
-}
-const METRIC_NAMES = [
-	"clicks",
-	"impressions",
-	"ctr",
-	"position"
-];
-const QUERY_DIM_ALIAS = "query_dim";
-function quoteIdent(id) {
-	return `"${id.replace(/"/g, "\"\"")}"`;
-}
-function qualifiedRaw(alias, column) {
-	return sql.raw(`${quoteIdent(alias)}.${quoteIdent(column)}`);
-}
-function defaultSqliteUrlToPathExpr(col) {
-	return `CASE WHEN ${col} LIKE 'http%' THEN CASE WHEN INSTR(SUBSTR(${col}, INSTR(${col}, '://') + 3), '/') > 0 THEN SUBSTR(${col}, INSTR(${col}, '://') + 2 + INSTR(SUBSTR(${col}, INSTR(${col}, '://') + 3), '/')) ELSE '/' END ELSE ${col} END`;
-}
-function buildDimensionColumnMap(datasetToTableKey) {
-	const entries = Object.entries(datasetToTableKey).map(([dataset, tableKey]) => {
-		const dims = LOGICAL_DATASETS[dataset].dimensions;
-		return [tableKey, Object.fromEntries(Object.entries(dims).map(([dim, binding]) => [dim, binding?.column ?? dim]))];
-	});
-	return Object.fromEntries(entries);
-}
-function createSqlFragments(config) {
-	const { schema, datasetToTableKey, metricCast, regexPredicate, tableLabel, includeSiteId, includeSearchType, urlToPathExpr: urlToPathExprOverride, tableRef: tableRefOverride, queryCanonicalSource = "queryDim", queryDimTableRef, queryDimSiteScoped = false } = config;
-	const DIM_COLUMN_MAP = buildDimensionColumnMap(datasetToTableKey);
-	function isMetricDimension(dim) {
-		return METRIC_NAMES.includes(dim);
-	}
-	function dimColumn(dim, table) {
-		return DIM_COLUMN_MAP[table]?.[dim] ?? dim;
-	}
-	function tableKeyForDataset(dataset) {
-		return datasetToTableKey[dataset];
-	}
-	function inferTable(dimensions, filterDims = []) {
-		if (!isDatasetResolvable(dimensions, filterDims)) throw new UnresolvableDatasetError(dimensions, filterDims);
-		return tableKeyForDataset(inferLogicalDataset(dimensions, filterDims));
-	}
-	const urlToPathExpr = urlToPathExprOverride ?? defaultSqliteUrlToPathExpr;
-	function colRef(tableKey, colName) {
-		const c = schema[tableKey][colName];
-		if (!c) throw new Error(`${tableLabel}: unknown column '${colName}' on ${tableKey}`);
-		return sql`${c}`;
-	}
-	function tableRef(tableKey) {
-		if (tableRefOverride) return tableRefOverride(tableKey);
-		return sql`${schema[tableKey]}`;
-	}
-	function fromSql(tableKey, options = {}) {
-		const base = tableRef(tableKey);
-		if (!options.queryCanonical || queryCanonicalSource !== "queryDim") return base;
-		return sql`${base} LEFT JOIN ${queryDimTableRef?.() ?? sql.raw(`${quoteIdent(QUERY_DIM_ALIAS)}`)} ON ${queryDimSiteScoped ? sql`${colRef(tableKey, "query")} = ${qualifiedRaw(QUERY_DIM_ALIAS, "query")} AND ${colRef(tableKey, "site_id")} = ${qualifiedRaw(QUERY_DIM_ALIAS, "site_id")}` : sql`${colRef(tableKey, "query")} = ${qualifiedRaw(QUERY_DIM_ALIAS, "query")}`}`;
-	}
-	function dateColRef(tableKey) {
-		return colRef(tableKey, "date");
-	}
-	function siteIdColRef(tableKey) {
-		return colRef(tableKey, "site_id");
-	}
-	function searchTypeColRef(tableKey) {
-		return colRef(tableKey, "search_type");
-	}
-	function dimExprSql(dim, tableKey) {
-		const colName = dimColumn(dim, tableKey);
-		if (dim === "page") return sql.raw(urlToPathExpr(colName));
-		if (dim === "queryCanonical") {
-			if (queryCanonicalSource === "queryDim") return sql`COALESCE(${qualifiedRaw(QUERY_DIM_ALIAS, "query_canonical")}, ${colRef(tableKey, "query")})`;
-			return qualifiedRaw(String(tableKey), "query_canonical");
-		}
-		return colRef(tableKey, colName);
-	}
-	function metricSql(metric, tableKey) {
-		const t = schema[tableKey];
-		switch (metric) {
-			case "clicks": return sql`CAST(SUM(${t.clicks}) AS ${sql.raw(metricCast)})`;
-			case "impressions": return sql`CAST(SUM(${t.impressions}) AS ${sql.raw(metricCast)})`;
-			case "ctr": return sql`CAST(SUM(${t.clicks}) AS ${sql.raw(metricCast)}) / NULLIF(SUM(${t.impressions}), 0)`;
-			case "position": return sql`SUM(${t.sum_position}) / NULLIF(SUM(${t.impressions}), 0) + 1`;
-		}
-	}
-	function havingPredicates(filters, tableKey) {
-		const preds = [];
-		for (const f of filters) {
-			const metric = f.dimension;
-			if (!isMetricDimension(metric)) continue;
-			const expr = metricSql(metric, tableKey);
-			const v = Number(f.expression);
-			switch (f.operator) {
-				case "metricGte":
-					preds.push(sql`${expr} >= ${v}`);
-					break;
-				case "metricGt":
-					preds.push(sql`${expr} > ${v}`);
-					break;
-				case "metricLte":
-					preds.push(sql`${expr} <= ${v}`);
-					break;
-				case "metricLt":
-					preds.push(sql`${expr} < ${v}`);
-					break;
-				case "metricBetween": {
-					const v2 = Number(f.expression2);
-					preds.push(sql`${expr} >= ${v} AND ${expr} <= ${v2}`);
-					break;
-				}
-			}
-		}
-		return preds;
-	}
-	function prefilterPredicates(filters, tableKey) {
-		const t = schema[tableKey];
-		const preds = [];
-		for (const f of filters) {
-			const metric = f.dimension;
-			let col;
-			if (metric === "clicks") col = t.clicks;
-			else if (metric === "impressions") col = t.impressions;
-			if (!col) continue;
-			const v = Number(f.expression);
-			switch (f.operator) {
-				case "metricGte":
-					preds.push(sql`${col} >= ${v}`);
-					break;
-				case "metricGt":
-					preds.push(sql`${col} > ${v}`);
-					break;
-				case "metricLte":
-					preds.push(sql`${col} <= ${v}`);
-					break;
-				case "metricLt":
-					preds.push(sql`${col} < ${v}`);
-					break;
-				case "metricBetween": {
-					const v2 = Number(f.expression2);
-					preds.push(sql`${col} >= ${v} AND ${col} <= ${v2}`);
-					break;
-				}
-			}
-		}
-		return preds;
-	}
-	function dimensionPredicates(filters, tableKey) {
-		const preds = [];
-		for (const f of filters) {
-			if (isMetricDimension(f.dimension)) continue;
-			if (f.dimension === "date") continue;
-			if (f.operator === "topLevel") continue;
-			const dim = f.dimension;
-			const cRef = dim === "queryCanonical" ? void 0 : colRef(tableKey, dimColumn(dim, tableKey));
-			const matchExpr = dim === "page" || dim === "queryCanonical" ? dimExprSql(dim, tableKey) : cRef;
-			const patternExpr = dim === "queryCanonical" ? matchExpr : cRef;
-			switch (f.operator) {
-				case "equals":
-					preds.push(sql`${matchExpr} = ${f.expression}`);
-					break;
-				case "notEquals":
-					preds.push(sql`${matchExpr} != ${f.expression}`);
-					break;
-				case "contains":
-					preds.push(sql`${patternExpr} LIKE ${`%${escapeLike(f.expression)}%`} ESCAPE '\\'`);
-					break;
-				case "notContains":
-					preds.push(sql`${patternExpr} NOT LIKE ${`%${escapeLike(f.expression)}%`} ESCAPE '\\'`);
-					break;
-				case "includingRegex":
-					preds.push(regexPredicate(patternExpr, f.expression, false));
-					break;
-				case "excludingRegex":
-					preds.push(regexPredicate(patternExpr, f.expression, true));
-					break;
-			}
-		}
-		return preds;
-	}
-	function topLevelPredicate(filters, tableKey) {
-		if (!filters.some((f) => f.operator === "topLevel")) return void 0;
-		const pathExpr = dimExprSql("page", tableKey);
-		return sql`LENGTH(${pathExpr}) - LENGTH(REPLACE(${pathExpr}, '/', '')) <= 1`;
-	}
-	return {
-		METRIC_NAMES,
-		DIM_COLUMN_MAP,
-		isMetricDimension,
-		tableKeyForDataset,
-		dimColumn,
-		inferTable,
-		urlToPathExpr,
-		colRef,
-		tableRef,
-		fromSql,
-		dateColRef,
-		siteIdColRef: includeSiteId ? siteIdColRef : void 0,
-		searchTypeColRef: includeSearchType ? searchTypeColRef : void 0,
-		dimExprSql,
-		metricSql,
-		havingPredicates,
-		prefilterPredicates,
-		dimensionPredicates,
-		topLevelPredicate
-	};
-}
-function createResolverAdapter(config) {
-	const runtime = createSqlFragments(config);
-	return {
-		METRIC_NAMES: runtime.METRIC_NAMES,
-		capabilities: config.capabilities,
-		schema: config.schema,
-		tableKeyForDataset: runtime.tableKeyForDataset,
-		inferTable: runtime.inferTable,
-		dimColumn: runtime.dimColumn,
-		isMetricDimension: runtime.isMetricDimension,
-		tableRef: runtime.tableRef,
-		fromSql: runtime.fromSql,
-		dateColRef: runtime.dateColRef,
-		urlToPathExpr: runtime.urlToPathExpr,
-		siteIdColRef: runtime.siteIdColRef,
-		searchTypeColRef: runtime.searchTypeColRef,
-		dimExprSql: runtime.dimExprSql,
-		metricSql: runtime.metricSql,
-		dimensionPredicates: runtime.dimensionPredicates,
-		havingPredicates: runtime.havingPredicates,
-		prefilterPredicates: runtime.prefilterPredicates,
-		topLevelPredicate: runtime.topLevelPredicate,
-		compile: config.compile
-	};
-}
-const ALLOWED_FILTER_DIMS = /* @__PURE__ */ new Set(["date", "queryCanonical"]);
-function planCoveredByCanonicalRollup(plan) {
-	if (plan.dataset !== "queries") return false;
-	if (plan.groupByDimensions.length !== 1 || plan.groupByDimensions[0] !== "queryCanonical") return false;
-	if (!plan.dimensionFilters.every((f) => ALLOWED_FILTER_DIMS.has(f.dimension))) return false;
-	if (plan.prefilters.length > 0) return false;
-	if (plan.specialFilters.topLevel) return false;
-	return true;
-}
-function canonicalRollupCovers(state, capabilities) {
-	return planCoveredByCanonicalRollup(buildLogicalPlan(state, capabilities));
-}
-const COMPARISON_FILTER_SQL = {
-	new: sql`AND COALESCE(p.impressions, 0) = 0 AND COALESCE(c.impressions, 0) > 0`,
-	lost: sql`AND COALESCE(p.impressions, 0) > 0 AND COALESCE(c.impressions, 0) = 0`,
-	improving: sql`AND COALESCE(c.clicks, 0) > COALESCE(p.clicks, 0)`,
-	declining: sql`AND COALESCE(c.clicks, 0) < COALESCE(p.clicks, 0) AND COALESCE(p.clicks, 0) > 0`
-};
-function collapseWs(s) {
-	return s.replace(/\s+/g, " ").trim();
-}
-function joinAnd(parts) {
-	return sql.join(parts, sql` AND `);
-}
-function joinComma(parts) {
-	return sql.join(parts, sql`, `);
-}
-const ORDER_BY_HELPER_PREFIX = "__order_";
-function withMinimumImpressions(state, options) {
-	if (options.minimumImpressions === void 0) return state;
-	const minimum = Number(options.minimumImpressions);
-	if (!Number.isFinite(minimum) || minimum < 0) throw new RangeError("minimumImpressions must be a finite non-negative number");
-	const guard = gte$1(impressions, minimum);
-	return {
-		...state,
-		prefilter: state.prefilter ? and$1(state.prefilter, guard) : guard
-	};
-}
-function orderByClause(state, prefix = "", columnOverride) {
-	if (state.orderBy) {
-		const safeCol = (columnOverride ?? state.orderBy.column).replace(/\W/g, "");
-		const safeDir = state.orderBy.dir.toUpperCase() === "ASC" ? "ASC" : "DESC";
-		return sql.raw(`ORDER BY ${prefix}${safeCol} ${safeDir}`);
-	}
-	return sql.raw(`ORDER BY ${prefix}clicks DESC`);
-}
-function limitOffsetClause(state) {
-	const rowLimit = Math.max(0, Math.floor(Number(state.rowLimit ?? 100)));
-	const offset = state.startRow ? Math.max(0, Math.floor(Number(state.startRow))) : 0;
-	return sql.raw(offset > 0 ? `LIMIT ${rowLimit} OFFSET ${offset}` : `LIMIT ${rowLimit}`);
-}
-function aliasRaw(name) {
-	const safe = name.replace(/\W/g, "");
-	return sql.raw(`"${safe}"`);
-}
-function toInternalDimensionFilters(filters) {
-	return filters.map((filter) => ({
-		dimension: filter.dimension,
-		operator: filter.operator,
-		expression: filter.expression,
-		expression2: filter.expression2
-	}));
-}
-function toInternalMetricFilters(filters) {
-	return filters.map((filter) => ({
-		dimension: filter.metric,
-		operator: filter.operator,
-		expression: String(filter.expression),
-		expression2: filter.expression2 == null ? void 0 : String(filter.expression2)
-	}));
-}
-function topLevelFilters(plan) {
-	if (!plan.specialFilters.topLevel) return [];
-	return [{
-		dimension: "page",
-		operator: "topLevel",
-		expression: ""
-	}];
-}
-function logicalFilterToInternal(filter) {
-	return {
-		dimension: filter.dimension,
-		operator: filter.operator,
-		expression: filter.expression,
-		expression2: filter.expression2
-	};
-}
-function compileFilterTree(node, adapter, tableKey) {
-	if (!node) return void 0;
-	if (node.kind === "leaf") return adapter.dimensionPredicates([logicalFilterToInternal(node.filter)], tableKey)[0];
-	const childSqls = node.children.map((child) => compileFilterTree(child, adapter, tableKey)).filter((s) => s !== void 0);
-	if (childSqls.length === 0) return void 0;
-	if (childSqls.length === 1) return childSqls[0];
-	const sep = node.groupType === "or" ? sql` OR ` : sql` AND `;
-	return sql`(${sql.join(childSqls, sep)})`;
-}
-function buildScope(state, options) {
-	const { adapter, siteId, searchType } = options;
-	const plan = buildLogicalPlan(state, adapter.capabilities);
-	const tableKey = adapter.tableKeyForDataset(plan.dataset);
-	const dimFilters = toInternalDimensionFilters(plan.dimensionFilters);
-	const metricFilters = toInternalMetricFilters(plan.metricFilters);
-	const prefilters = toInternalMetricFilters(plan.prefilters);
-	const groupByDims = plan.groupByDimensions;
-	const hasDate = plan.hasDate;
-	const metrics = plan.metrics;
-	const queryCanonicalUsed = groupByDims.includes("queryCanonical") || plan.dimensionFilters.some((filter) => filter.dimension === "queryCanonical");
-	const wherePredicates = [];
-	if (adapter.siteIdColRef && siteId != null) wherePredicates.push(sql`${adapter.siteIdColRef(tableKey)} = ${siteId}`);
-	if (adapter.searchTypeColRef && searchType != null) wherePredicates.push(sql`${adapter.searchTypeColRef(tableKey)} = ${searchType}`);
-	wherePredicates.push(sql`${adapter.dateColRef(tableKey)} >= ${plan.dateRange.startDate}`);
-	wherePredicates.push(sql`${adapter.dateColRef(tableKey)} <= ${plan.dateRange.endDate}`);
-	wherePredicates.push(...adapter.prefilterPredicates(prefilters, tableKey));
-	const dimSql = plan.dimensionFilterTree ? compileFilterTree(plan.dimensionFilterTree, adapter, tableKey) : void 0;
-	if (dimSql) wherePredicates.push(dimSql);
-	else if (!plan.dimensionFilterTree) wherePredicates.push(...adapter.dimensionPredicates(dimFilters, tableKey));
-	const tl = adapter.topLevelPredicate(topLevelFilters(plan), tableKey);
-	if (tl) wherePredicates.push(tl);
-	return {
-		plan,
-		tableKey,
-		groupByDims,
-		hasDate,
-		metrics,
-		wherePredicates,
-		having: adapter.havingPredicates(metricFilters, tableKey),
-		dimFilters,
-		startDate: plan.dateRange.startDate,
-		endDate: plan.dateRange.endDate,
-		queryCanonicalUsed
-	};
-}
-function buildComparisonPlan(current, previous, capabilities) {
-	return buildLogicalComparisonPlan(current, previous, capabilities);
-}
-function compileCollapsed(adapter, q) {
-	const c = adapter.compile(q);
-	return {
-		sql: collapseWs(c.sql),
-		params: c.params
-	};
-}
-function resolveToSQLOptimized(state, options) {
-	state = withMinimumImpressions(state, options);
-	const { adapter } = options;
-	const { tableKey, groupByDims, hasDate, metrics, wherePredicates, having, queryCanonicalUsed } = buildScope(state, options);
-	const table = adapter.fromSql(tableKey, { queryCanonical: queryCanonicalUsed });
-	const schema = adapter.schema;
-	const cteSelect = [];
-	for (const d of groupByDims) {
-		const expr = adapter.dimExprSql(d, tableKey);
-		const colName = adapter.dimColumn(d, tableKey);
-		if (d === "page" || colName !== d) cteSelect.push(sql`${expr} as ${aliasRaw(d)}`);
-		else cteSelect.push(expr);
-	}
-	if (hasDate) cteSelect.push(adapter.dateColRef(tableKey));
-	const t = schema[tableKey];
-	cteSelect.push(sql`CAST(SUM(${t.clicks}) AS DOUBLE) as clicks`);
-	cteSelect.push(sql`CAST(SUM(${t.impressions}) AS DOUBLE) as impressions`);
-	cteSelect.push(sql`CAST(SUM(${t.sum_position}) AS DOUBLE) as sum_position`);
-	const groupByExprs = groupByDims.map((d) => adapter.dimExprSql(d, tableKey));
-	if (hasDate) groupByExprs.push(adapter.dateColRef(tableKey));
-	const outerSelect = [];
-	for (const d of groupByDims) outerSelect.push(aliasRaw(d));
-	if (hasDate) outerSelect.push(sql.raw("date"));
-	const outerTotals = [];
-	for (const m of metrics) switch (m) {
-		case "clicks":
-			outerSelect.push(sql.raw("clicks"));
-			outerTotals.push(sql.raw("CAST(SUM(clicks) OVER() AS DOUBLE) as totalClicks"));
-			break;
-		case "impressions":
-			outerSelect.push(sql.raw("impressions"));
-			outerTotals.push(sql.raw("CAST(SUM(impressions) OVER() AS DOUBLE) as totalImpressions"));
-			break;
-		case "ctr":
-			outerSelect.push(sql.raw("CAST(clicks AS REAL) / NULLIF(impressions, 0) as ctr"));
-			outerTotals.push(sql.raw("CAST(SUM(clicks) OVER() AS REAL) / NULLIF(SUM(impressions) OVER(), 0) as totalCtr"));
-			break;
-		case "position":
-			outerSelect.push(sql.raw("sum_position / NULLIF(impressions, 0) + 1 as position"));
-			outerTotals.push(sql.raw("SUM(sum_position) OVER() / NULLIF(SUM(impressions) OVER(), 0) + 1 as totalPosition"));
-			break;
-	}
-	let orderByColumnOverride;
-	const orderColumn = state.orderBy?.column;
-	if (orderColumn && orderColumn !== "date" && !metrics.includes(orderColumn)) {
-		orderByColumnOverride = `${ORDER_BY_HELPER_PREFIX}${orderColumn}`;
-		switch (orderColumn) {
-			case "clicks":
-				outerSelect.push(sql.raw(`clicks as "${orderByColumnOverride}"`));
-				break;
-			case "impressions":
-				outerSelect.push(sql.raw(`impressions as "${orderByColumnOverride}"`));
-				break;
-			case "ctr":
-				outerSelect.push(sql.raw(`CAST(clicks AS REAL) / NULLIF(impressions, 0) as "${orderByColumnOverride}"`));
-				break;
-			case "position":
-				outerSelect.push(sql.raw(`sum_position / NULLIF(impressions, 0) + 1 as "${orderByColumnOverride}"`));
-				break;
-		}
-	}
-	outerSelect.push(sql.raw("COUNT(*) OVER() as totalCount"));
-	for (const totalExpr of outerTotals) outerSelect.push(totalExpr);
-	let cte = wherePredicates.length > 0 ? sql`SELECT ${joinComma(cteSelect)} FROM ${table} WHERE ${joinAnd(wherePredicates)}` : sql`SELECT ${joinComma(cteSelect)} FROM ${table}`;
-	if (groupByExprs.length > 0) cte = sql`${cte} GROUP BY ${joinComma(groupByExprs)}`;
-	if (having.length > 0) cte = sql`${cte} HAVING ${joinAnd(having)}`;
-	return compileCollapsed(adapter, sql`WITH aggregated AS (${cte}) SELECT ${joinComma(outerSelect)} FROM aggregated ${orderByClause(state, "", orderByColumnOverride)} ${limitOffsetClause(state)}`);
-}
-function resolveToSQL(state, options) {
-	state = withMinimumImpressions(state, options);
-	const { adapter } = options;
-	const { tableKey, groupByDims, hasDate, metrics, wherePredicates, having, queryCanonicalUsed } = buildScope(state, options);
-	const table = adapter.fromSql(tableKey, { queryCanonical: queryCanonicalUsed });
-	const selectExprs = [];
-	for (const d of groupByDims) {
-		const expr = adapter.dimExprSql(d, tableKey);
-		const colName = adapter.dimColumn(d, tableKey);
-		if (d === "page" || colName !== d) selectExprs.push(sql`${expr} as ${aliasRaw(d)}`);
-		else selectExprs.push(expr);
-	}
-	if (hasDate) selectExprs.push(adapter.dateColRef(tableKey));
-	for (const m of metrics) selectExprs.push(sql`${adapter.metricSql(m, tableKey)} as ${aliasRaw(m)}`);
-	const groupByExprs = groupByDims.map((d) => adapter.dimExprSql(d, tableKey));
-	if (hasDate) groupByExprs.push(adapter.dateColRef(tableKey));
-	let body = wherePredicates.length > 0 ? sql`SELECT ${joinComma(selectExprs)} FROM ${table} WHERE ${joinAnd(wherePredicates)}` : sql`SELECT ${joinComma(selectExprs)} FROM ${table}`;
-	if (groupByExprs.length > 0) body = sql`${body} GROUP BY ${joinComma(groupByExprs)}`;
-	if (having.length > 0) body = sql`${body} HAVING ${joinAnd(having)}`;
-	const mainQuery = sql`${body} ${orderByClause(state)} ${limitOffsetClause(state)}`;
-	let countQuery;
-	if (groupByExprs.length > 0) {
-		let inner = wherePredicates.length > 0 ? sql`SELECT ${joinComma(groupByExprs)} FROM ${table} WHERE ${joinAnd(wherePredicates)} GROUP BY ${joinComma(groupByExprs)}` : sql`SELECT ${joinComma(groupByExprs)} FROM ${table} GROUP BY ${joinComma(groupByExprs)}`;
-		if (having.length > 0) inner = sql`${inner} HAVING ${joinAnd(having)}`;
-		countQuery = sql`SELECT COUNT(*) as total FROM (${inner})`;
-	} else countQuery = wherePredicates.length > 0 ? sql`SELECT COUNT(*) as total FROM ${table} WHERE ${joinAnd(wherePredicates)}` : sql`SELECT COUNT(*) as total FROM ${table}`;
-	const main = compileCollapsed(adapter, mainQuery);
-	const count = compileCollapsed(adapter, countQuery);
-	return {
-		sql: main.sql,
-		params: main.params,
-		countSql: count.sql,
-		countParams: count.params
-	};
-}
-function buildTotalsSql(state, options) {
-	state = withMinimumImpressions(state, options);
-	const { adapter } = options;
-	const { tableKey, metrics, wherePredicates, queryCanonicalUsed } = buildScope(state, options);
-	const table = adapter.fromSql(tableKey, { queryCanonical: queryCanonicalUsed });
-	const selectExprs = metrics.map((m) => sql`${adapter.metricSql(m, tableKey)} as ${aliasRaw(m)}`);
-	return compileCollapsed(adapter, wherePredicates.length > 0 ? sql`SELECT ${joinComma(selectExprs)} FROM ${table} WHERE ${joinAnd(wherePredicates)}` : sql`SELECT ${joinComma(selectExprs)} FROM ${table}`);
-}
-function resolveComparisonSQL(current, previous, options, comparisonFilter) {
-	const { adapter, siteId, searchType } = options;
-	const comparisonPlan = buildComparisonPlan(current, previous, adapter.capabilities);
-	const currentScope = buildScope(current, options);
-	const previousScope = buildScope(previous, options);
-	const { tableKey, groupByDims, metrics, wherePredicates: currentWhere, having } = currentScope;
-	const table = adapter.fromSql(tableKey, { queryCanonical: currentScope.queryCanonicalUsed || previousScope.queryCanonicalUsed });
-	const dimSelectExprs = [];
-	for (const d of groupByDims) {
-		const expr = adapter.dimExprSql(d, tableKey);
-		const colName = adapter.dimColumn(d, tableKey);
-		if (d === "page" || colName !== d) dimSelectExprs.push(sql`${expr} as ${aliasRaw(d)}`);
-		else dimSelectExprs.push(expr);
-	}
-	const currentSelect = [...dimSelectExprs, ...metrics.map((m) => sql`${adapter.metricSql(m, tableKey)} as ${aliasRaw(m)}`)];
-	const prevSelect = [...dimSelectExprs, ...adapter.METRIC_NAMES.map((m) => sql`${adapter.metricSql(m, tableKey)} as ${aliasRaw(m)}`)];
-	const groupByExprs = groupByDims.map((d) => adapter.dimExprSql(d, tableKey));
-	const prevWhere = [];
-	if (adapter.siteIdColRef && siteId != null) prevWhere.push(sql`${adapter.siteIdColRef(tableKey)} = ${siteId}`);
-	if (adapter.searchTypeColRef && searchType != null) prevWhere.push(sql`${adapter.searchTypeColRef(tableKey)} = ${searchType}`);
-	if (previousScope.startDate) prevWhere.push(sql`${adapter.dateColRef(tableKey)} >= ${previousScope.startDate}`);
-	if (previousScope.endDate) prevWhere.push(sql`${adapter.dateColRef(tableKey)} <= ${previousScope.endDate}`);
-	const prevDimSql = comparisonPlan.current.dimensionFilterTree ? compileFilterTree(comparisonPlan.current.dimensionFilterTree, adapter, tableKey) : void 0;
-	if (prevDimSql) prevWhere.push(prevDimSql);
-	else if (!comparisonPlan.current.dimensionFilterTree) prevWhere.push(...adapter.dimensionPredicates(toInternalDimensionFilters(comparisonPlan.current.dimensionFilters), tableKey));
-	let currentCte = currentWhere.length > 0 ? sql`SELECT ${joinComma(currentSelect)} FROM ${table} WHERE ${joinAnd(currentWhere)}` : sql`SELECT ${joinComma(currentSelect)} FROM ${table}`;
-	if (groupByExprs.length > 0) currentCte = sql`${currentCte} GROUP BY ${joinComma(groupByExprs)}`;
-	if (having.length > 0) currentCte = sql`${currentCte} HAVING ${joinAnd(having)}`;
-	let previousCte = prevWhere.length > 0 ? sql`SELECT ${joinComma(prevSelect)} FROM ${table} WHERE ${joinAnd(prevWhere)}` : sql`SELECT ${joinComma(prevSelect)} FROM ${table}`;
-	if (groupByExprs.length > 0) previousCte = sql`${previousCte} GROUP BY ${joinComma(groupByExprs)}`;
-	const joinOn = groupByDims.length > 0 ? sql.raw(groupByDims.map((d) => `c.${d.replace(/\W/g, "")} = p.${d.replace(/\W/g, "")}`).join(" AND ")) : sql.raw("1=1");
-	const filterClause = comparisonFilter ? COMPARISON_FILTER_SQL[comparisonFilter] : sql.raw("");
-	const orderSql = orderByClause(current, "");
-	const limitSql = limitOffsetClause(current);
-	const outerCurrentCols = [];
-	for (const d of groupByDims) {
-		const colName = d.replace(/\W/g, "");
-		outerCurrentCols.push(sql.raw(`COALESCE(c.${colName}, p.${colName}) as "${colName}"`));
-	}
-	outerCurrentCols.push(sql.raw("CAST(COALESCE(c.clicks, 0) AS DOUBLE) as \"clicks\""));
-	outerCurrentCols.push(sql.raw("CAST(COALESCE(c.impressions, 0) AS DOUBLE) as \"impressions\""));
-	outerCurrentCols.push(sql.raw("COALESCE(c.ctr, 0) as \"ctr\""));
-	outerCurrentCols.push(sql.raw("COALESCE(c.position, 0) as \"position\""));
-	const mainQuery = sql`WITH current AS (${currentCte}), previous AS (${previousCte}) SELECT ${joinComma(outerCurrentCols)}, COALESCE(CAST(p.clicks AS DOUBLE), 0) as "prevClicks", COALESCE(CAST(p.impressions AS DOUBLE), 0) as "prevImpressions", COALESCE(p.ctr, 0) as "prevCtr", COALESCE(p.position, 0) as "prevPosition" FROM current c FULL OUTER JOIN previous p ON ${joinOn} WHERE 1=1 ${filterClause} ${orderSql} ${limitSql}`;
-	const firstGroupBy = groupByDims[0] ? groupByDims[0].replace(/\W/g, "") : "clicks";
-	const countInnerSelect = groupByDims[0] ? sql.raw(`COALESCE(c.${firstGroupBy}, p.${firstGroupBy})`) : sql.raw(`c.${firstGroupBy}`);
-	const countQuery = sql`WITH current AS (${currentCte}), previous AS (${previousCte}) SELECT COUNT(*) as total FROM (SELECT ${countInnerSelect} FROM current c FULL OUTER JOIN previous p ON ${joinOn} WHERE 1=1 ${filterClause})`;
-	const main = compileCollapsed(adapter, mainQuery);
-	const count = compileCollapsed(adapter, countQuery);
-	return {
-		sql: main.sql,
-		params: main.params,
-		countSql: count.sql,
-		countParams: count.params
-	};
-}
-function buildExtrasQueries(state, options) {
-	const { adapter, siteId, searchType } = options;
-	const plan = buildLogicalPlan(state, adapter.capabilities);
-	const dims = plan.groupByDimensions;
-	const extras = [];
-	if (!dims.includes("queryCanonical")) return extras;
-	const queriesKey = adapter.tableKeyForDataset("queries");
-	const t = adapter.schema[queriesKey];
-	const table = adapter.fromSql(queriesKey, { queryCanonical: true });
-	const whereParts = [];
-	if (adapter.siteIdColRef && siteId != null) whereParts.push(sql`${adapter.siteIdColRef(queriesKey)} = ${siteId}`);
-	if (adapter.searchTypeColRef && searchType != null) whereParts.push(sql`${adapter.searchTypeColRef(queriesKey)} = ${searchType}`);
-	whereParts.push(sql`${adapter.dateColRef(queriesKey)} >= ${plan.dateRange.startDate}`);
-	whereParts.push(sql`${adapter.dateColRef(queriesKey)} <= ${plan.dateRange.endDate}`);
-	const whereExpr = whereParts.length > 0 ? sql`WHERE ${joinAnd(whereParts)}` : sql``;
-	const outerQueryCol = sql.raw("query");
-	const canonKey = adapter.dimExprSql("queryCanonical", queriesKey);
-	const compiled = compileCollapsed(adapter, sql`WITH per_variant AS (SELECT ${canonKey} as joinKey, ${t.query} as query, SUM(${t.clicks}) as clicks, SUM(${t.impressions}) as impressions, SUM(${t.sum_position}) as sum_pos, ROW_NUMBER() OVER (PARTITION BY ${canonKey} ORDER BY SUM(${t.clicks}) DESC) as rn, COUNT(*) OVER (PARTITION BY ${canonKey}) as variantCount FROM ${table} ${whereExpr} GROUP BY ${canonKey}, ${t.query}) SELECT joinKey, MAX(variantCount) as variantCount, MAX(CASE WHEN rn = 1 THEN ${outerQueryCol} END) as canonicalName, GROUP_CONCAT(CASE WHEN rn <= 10 THEN ${outerQueryCol} || ':::' || clicks || ':::' || impressions || ':::' || CAST(ROUND(CAST(sum_pos AS REAL) / NULLIF(impressions, 0) + 1, 1) AS TEXT) END, '||') as variants FROM per_variant GROUP BY joinKey`);
-	extras.push({
-		key: "canonicalExtras",
-		sql: compiled.sql,
-		params: compiled.params
-	});
-	return extras;
-}
-function mergeExtras(rows, extrasResults) {
-	if (extrasResults.length === 0) return rows;
-	const lookups = [];
-	const parseVariants = (raw) => {
-		if (raw.length === 0) return [];
-		const encoded = raw.split("||");
-		const variants = [];
-		for (const value of encoded) {
-			if (value.length === 0) continue;
-			const parts = value.split(":::");
-			variants.push({
-				query: parts[0],
-				clicks: Number(parts[1] || 0),
-				impressions: Number(parts[2] || 0),
-				position: Number(parts[3] || 0)
-			});
-		}
-		return variants;
-	};
-	for (const { key, results } of extrasResults) {
-		if (key === "canonicalExtras") {
-			const map = /* @__PURE__ */ new Map();
-			for (const r of results) {
-				const jk = String(r.joinKey);
-				const raw = r.variants;
-				map.set(jk, {
-					variantCount: r.variantCount,
-					variants: typeof raw === "string" ? parseVariants(raw) : [],
-					canonicalName: r.canonicalName
-				});
-			}
-			lookups.push({
-				kind: "canonical",
-				map
-			});
-			continue;
-		}
-		const map = /* @__PURE__ */ new Map();
-		for (const r of results) {
-			if (r.rn !== void 0 && r.rn !== 1) continue;
-			let val = r[key];
-			if (key === "variants" && typeof val === "string") val = parseVariants(val);
-			map.set(String(r.joinKey), val);
-		}
-		lookups.push({
-			kind: "generic",
-			key,
-			map
-		});
-	}
-	return rows.map((row) => {
-		const enriched = { ...row };
-		for (const lookup of lookups) {
-			if (lookup.kind === "canonical") {
-				const joinValue = String(row.queryCanonical ?? row.query_canonical ?? "");
-				const extra = joinValue ? lookup.map.get(joinValue) : void 0;
-				enriched.variantCount = extra?.variantCount ?? null;
-				enriched.variants = extra?.variants ?? [];
-				enriched.canonicalName = extra?.canonicalName ?? null;
-				if (enriched.canonicalName) enriched.queryCanonical = enriched.canonicalName;
-				continue;
-			}
-			const { key, map } = lookup;
-			const joinValue = key === "variantCount" || key === "variants" || key === "canonicalName" ? String(row.queryCanonical ?? row.query_canonical ?? "") : void 0;
-			enriched[key] = (joinValue && map.get(joinValue)) ?? (key === "variants" ? [] : null);
-			if (key === "canonicalName" && enriched[key]) enriched.queryCanonical = enriched[key];
-		}
-		return enriched;
-	});
-}
-const EXTRA_ROLLUP_IDS = { canonicalExtras: "query_canonical_variants" };
-function createRollupExtrasOverlay(readRollupRows) {
-	return async ({ key, ctx, dateRange }) => {
-		const id = EXTRA_ROLLUP_IDS[key];
-		if (id === void 0) return null;
-		return readRollupRows({
-			id,
-			ctx: {
-				userId: ctx.userId,
-				siteId: ctx.siteId
-			},
-			dateRange,
-			...ctx.searchType !== void 0 ? { searchType: ctx.searchType } : {}
-		});
-	};
-}
-function collectInternalFilters(filter) {
-	if (!filter || !("_filters" in filter)) return [];
-	const flat = filter._filters;
-	const nested = filter._nestedGroups?.flatMap((group) => collectInternalFilters(group)) ?? [];
-	return [...flat, ...nested];
-}
-function getInternalFilters(filter) {
-	return collectInternalFilters(filter);
-}
-function getDimensionFilters(filter, isMetricDimension) {
-	return collectInternalFilters(filter).filter((f) => f.dimension !== "date" && !isMetricDimension(f.dimension) && f.operator !== "topLevel" && !f.operator.startsWith("metric"));
-}
-function getFilterDimensions(filter, isMetricDimension) {
-	return getDimensionFilters(filter, isMetricDimension).map((f) => f.dimension);
-}
-function metricValue(row, metric) {
-	const value = row[metric];
-	if (typeof value === "number") return value;
-	if (typeof value === "bigint") return Number(value);
-	if (value == null) return 0;
-	return Number(value);
-}
-function dimensionValue(row, dimension) {
-	const value = row[dimension];
-	return value == null ? "" : String(value);
-}
-function matchesDimensionFilter(row, filter) {
-	const raw = dimensionValue(row, filter.dimension);
-	const value = filter.dimension === "page" ? normalizeUrl(raw) : raw;
-	switch (filter.operator) {
-		case "equals": return value === filter.expression;
-		case "notEquals": return value !== filter.expression;
-		case "contains": return raw.includes(filter.expression);
-		case "notContains": return !raw.includes(filter.expression);
-		case "includingRegex": return new RegExp(filter.expression).test(raw);
-		case "excludingRegex": return !new RegExp(filter.expression).test(raw);
-		default: return true;
-	}
-}
-function matchesMetricFilter(row, filter) {
-	const value = metricValue(row, filter.dimension);
-	const target = Number(filter.expression);
-	switch (filter.operator) {
-		case "metricGte": return value >= target;
-		case "metricGt": return value > target;
-		case "metricLte": return value <= target;
-		case "metricLt": return value < target;
-		case "metricBetween": return value >= target && value <= Number(filter.expression2);
-		default: return true;
-	}
-}
-function matchesTopLevelPage(row) {
-	const path = normalizeUrl(dimensionValue(row, "page"));
-	let slashes = 0;
-	for (let index = 0; index < path.length; index++) if (path.charCodeAt(index) === 47 && ++slashes > 1) return false;
-	return true;
-}
-const pgDialect = new PgDialect();
-function withTenantCols(tableName, baseTable) {
-	const t = pgTable(tableName, {
-		site_id: varchar("site_id").notNull(),
-		search_type: varchar("search_type").notNull()
-	});
-	return {
-		...baseTable,
-		site_id: t.site_id,
-		search_type: t.search_type
-	};
-}
-const icebergSchema = {
-	pages: withTenantCols("pages", drizzleSchema.pages),
-	queries: withTenantCols("queries", drizzleSchema.queries),
-	countries: withTenantCols("countries", drizzleSchema.countries),
-	page_queries: withTenantCols("page_queries", drizzleSchema.page_queries),
-	dates: withTenantCols("dates", drizzleSchema.dates),
-	search_appearance: withTenantCols("search_appearance", drizzleSchema.search_appearance),
-	search_appearance_pages: withTenantCols("search_appearance_pages", drizzleSchema.search_appearance_pages),
-	search_appearance_queries: withTenantCols("search_appearance_queries", drizzleSchema.search_appearance_queries),
-	search_appearance_page_queries: withTenantCols("search_appearance_page_queries", drizzleSchema.search_appearance_page_queries),
-	hourly_pages: withTenantCols("hourly_pages", drizzleSchema.hourly_pages)
-};
-function compilePg(query) {
-	const compiled = pgDialect.sqlToQuery(query);
-	return {
-		sql: compiled.sql,
-		params: compiled.params
-	};
-}
-const PG_BASE_CONFIG = {
-	schema: drizzleSchema,
-	datasetToTableKey: {
-		pages: "pages",
-		queries: "queries",
-		page_queries: "page_queries",
-		countries: "countries",
-		dates: "dates",
-		search_appearance: "search_appearance",
-		search_appearance_pages: "search_appearance_pages",
-		search_appearance_queries: "search_appearance_queries",
-		search_appearance_page_queries: "search_appearance_page_queries",
-		hourly_pages: "hourly_pages"
-	},
-	metricCast: "DOUBLE",
-	regexPredicate: (expr, pattern, negate) => negate ? sql`NOT regexp_matches(${expr}, ${pattern})` : sql`regexp_matches(${expr}, ${pattern})`,
-	urlToPathExpr: (col) => `CASE WHEN ${col} LIKE 'http%' THEN COALESCE(NULLIF(regexp_replace(${col}, '^https?://[^/]+', ''), ''), '/') ELSE ${col} END`,
-	includeSiteId: false,
-	compile: compilePg,
-	capabilities: {
-		regex: true,
-		comparisonJoin: true,
-		windowTotals: true
-	}
-};
-const pgResolverAdapter = createResolverAdapter({
-	...PG_BASE_CONFIG,
-	tableLabel: "pg-resolver-adapter"
-});
-function createParquetResolverAdapter(options = {}) {
-	return createResolverAdapter({
-		...PG_BASE_CONFIG,
-		tableLabel: "parquet-resolver-adapter",
-		queryCanonicalSource: options.queryCanonicalSource ?? "queryDim",
-		tableRef: (tk) => sql.raw(`read_parquet({{FILES}}, union_by_name = true) AS "${tk}"`),
-		queryDimTableRef: () => sql.raw("read_parquet({{QUERY_DIM}}, union_by_name = true) AS \"query_dim\"")
-	});
-}
-function createIcebergResolverAdapter(options = {}) {
-	return createResolverAdapter({
-		...PG_BASE_CONFIG,
-		schema: icebergSchema,
-		includeSiteId: true,
-		includeSearchType: true,
-		tableLabel: "iceberg-resolver-adapter",
-		queryCanonicalSource: options.queryCanonicalSource ?? "queryDim",
-		tableRef: (tk) => sql.raw(`"${tk}"`),
-		queryDimTableRef: () => sql.raw("\"query_dim\"")
-	});
-}
-function createR2SqlResolverAdapter(options = {}) {
-	const adapter = createResolverAdapter({
-		...PG_BASE_CONFIG,
-		schema: icebergSchema,
-		includeSiteId: true,
-		includeSearchType: true,
-		tableLabel: "r2-sql-resolver-adapter",
-		queryCanonicalSource: options.queryCanonicalSource ?? "queryDim",
-		capabilities: {
-			regex: false,
-			comparisonJoin: false,
-			windowTotals: false
-		},
-		tableRef: (tk) => sql.raw(`"${tk}"`),
-		queryDimTableRef: () => sql.raw("\"query_dim\"")
-	});
-	if ((options.partitionKeyEncoding ?? DEFAULT_PARTITION_KEY_ENCODING) === "int") return adapter;
-	return {
-		...adapter,
-		siteIdColRef: (tk) => sql`CONCAT(${adapter.siteIdColRef(tk)}, '')`,
-		searchTypeColRef: (tk) => sql`CONCAT(${adapter.searchTypeColRef(tk)}, '')`
-	};
-}
-var QuerySourceCoverageError = class extends Error {
-	fallback;
-	name = "QuerySourceCoverageError";
-	constructor(fallback) {
-		super(fallback.message);
-		this.fallback = fallback;
-	}
-};
-function canonicalSourceWithinCoverage(source, windowEnd) {
-	return source.coversThrough === void 0 || windowEnd <= source.coversThrough;
-}
-function querySourceDecision(kind, fallbacks = []) {
-	const first = fallbacks[0];
-	return {
-		kind,
-		...first ? {
-			fallback: first,
-			fallbacks
-		} : {}
-	};
-}
-function canonicalFeatureRequested(state, capabilities) {
-	const plan = buildLogicalPlan(state, capabilities);
-	return plan.groupByDimensions.includes("queryCanonical") || plan.dimensionFilters.some((f) => f.dimension === "queryCanonical");
-}
-function fallback(kind, message) {
-	return {
-		kind,
-		message
-	};
-}
-function staleQueryDim(source, requirements) {
-	if (requirements?.normalizerVersion !== void 0 && source.normalizerVersion !== requirements.normalizerVersion) return fallback("query-dim-stale-version", `canonical query dimension normalizer v${source.normalizerVersion} does not match required v${requirements.normalizerVersion}`);
-	if (requirements?.intentVersion !== void 0 && source.intentVersion !== requirements.intentVersion) return fallback("query-dim-stale-version", `canonical query dimension intent v${source.intentVersion ?? "missing"} does not match required v${requirements.intentVersion}`);
-}
-function canonicalQueryDim(options) {
-	return options.queryDim ?? options.canonicalSource?.queryDim;
-}
-function queryDimMiss(source, requirements) {
-	if (!source) return fallback("query-dim-missing", "canonical query requires queryDim; fact tables do not carry query_canonical");
-	if (source.keys.length === 0) return fallback("query-dim-empty", "queryDim has no parquet keys; refusing to run canonical query from an empty dimension");
-	return staleQueryDim(source, requirements);
-}
-function decideCanonicalSource(state, capabilities, options, windowEnd) {
-	if (!canonicalFeatureRequested(state, capabilities)) return querySourceDecision("raw-partitions");
-	const dimMiss = queryDimMiss(canonicalQueryDim(options), options.canonicalRequirements);
-	if (dimMiss) throw new QuerySourceCoverageError(dimMiss);
-	const source = options.canonicalSource;
-	const miss = (() => {
-		if (!source) return fallback("canonical-source-missing", "canonical rollup source missing; falling back to primary facts joined through query_dim");
-		if (source.keys.length === 0) return fallback("canonical-source-empty", "canonicalSource has no parquet keys; falling back to primary facts joined through query_dim");
-		if (!canonicalSourceWithinCoverage(source, windowEnd)) return fallback("canonical-source-stale-coverage", `canonicalSource covers through ${source.coversThrough}, but query needs ${windowEnd}`);
-		if (!canonicalRollupCovers(state, capabilities)) return fallback("canonical-source-not-coverable", "canonicalSource only covers queryCanonical/date reads without raw-grain filters");
-	})();
-	if (!miss) return querySourceDecision("canonical-rollup");
-	return querySourceDecision("raw-partitions", [miss]);
-}
-function primarySourceMiss(source, dateRange) {
-	if (!source) return fallback("primary-source-missing", "primary columnar source is required; pass primarySourceFallback: \"raw\" to use raw daily partitions explicitly");
-	if (source.keys.length === 0) return fallback("primary-source-empty", "primarySource has no parquet keys; refusing to return partial or empty data implicitly");
-	if (source.coversFrom !== void 0 && dateRange.startDate < source.coversFrom) return fallback("primary-source-missing-coverage", `primarySource covers from ${source.coversFrom}, but query starts ${dateRange.startDate}`);
-	if (source.coversThrough !== void 0 && dateRange.endDate > source.coversThrough) return fallback("primary-source-stale-coverage", `primarySource covers through ${source.coversThrough}, but query needs ${dateRange.endDate}`);
-}
-function decidePrimarySource(options, dateRange, priorFallbacks = []) {
-	const miss = primarySourceMiss(options.primarySource, dateRange);
-	if (!miss) return querySourceDecision("primary-columnar", priorFallbacks);
-	const fallbacks = [...priorFallbacks, miss];
-	if (options.primarySourceFallback === "raw") return querySourceDecision("raw-partitions", fallbacks);
-	throw new QuerySourceCoverageError(miss);
-}
-function sourceFallbacks(source) {
-	if (source.fallbacks) return source.fallbacks;
-	return source.fallback ? [source.fallback] : [];
-}
-function runArgs(ctx, partitions) {
-	return {
-		ctx: {
-			userId: ctx.userId,
-			siteId: ctx.siteId
-		},
-		table: ctx.table,
-		fileSets: { FILES: {
-			table: ctx.table,
-			partitions
-		} },
-		...ctx.searchType !== void 0 ? { searchType: ctx.searchType } : {}
-	};
-}
-function primaryRunArgs(ctx, keys) {
-	return {
-		ctx: {
-			userId: ctx.userId,
-			siteId: ctx.siteId
-		},
-		table: ctx.table,
-		fileSets: { FILES: {
-			table: ctx.table,
-			keys
-		} },
-		...ctx.searchType !== void 0 ? { searchType: ctx.searchType } : {}
-	};
-}
-function withQueryDimFileSet(args, queryDim, enabled) {
-	if (!enabled || !queryDim) return args;
-	return {
-		...args,
-		fileSets: {
-			...args.fileSets,
-			QUERY_DIM: {
-				table: "queries",
-				keys: queryDim.keys
-			}
-		}
-	};
-}
-async function runOptimizedQuery(runSQL, ctx, state, dateRange, options = {}) {
-	const base = runArgs(ctx, enumeratePartitions(dateRange.startDate, dateRange.endDate));
-	const probe = createParquetResolverAdapter();
-	const canonicalRequested = canonicalFeatureRequested(state, probe.capabilities);
-	const canonicalDecision = decideCanonicalSource(state, probe.capabilities, options, dateRange.endDate);
-	const useCanonicalSource = canonicalDecision.kind === "canonical-rollup";
-	const source = useCanonicalSource ? canonicalDecision : decidePrimarySource(options, dateRange, sourceFallbacks(canonicalDecision));
-	const optimized = resolveToSQLOptimized(state, {
-		adapter: useCanonicalSource ? createParquetResolverAdapter({ queryCanonicalSource: "column" }) : probe,
-		siteId: void 0
-	});
-	const extras = buildExtrasQueries(state, {
-		adapter: probe,
-		siteId: void 0
-	});
-	const extraSource = extras.length > 0 ? useCanonicalSource ? decidePrimarySource(options, dateRange) : source : void 0;
-	const queryDim = canonicalQueryDim(options);
-	const mainArgs = withQueryDimFileSet(useCanonicalSource ? {
-		...base,
-		fileSets: { FILES: {
-			table: ctx.table,
-			keys: options.canonicalSource.keys
-		} }
-	} : source.kind === "primary-columnar" ? primaryRunArgs(ctx, options.primarySource.keys) : base, queryDim, canonicalRequested && !useCanonicalSource);
-	const extraArgs = withQueryDimFileSet(extraSource?.kind === "primary-columnar" ? primaryRunArgs(ctx, options.primarySource.keys) : base, queryDim, extras.length > 0);
-	const resolveExtra = options.resolveExtra;
-	const [optRes, ...extrasRows] = await Promise.all([runSQL({
-		...mainArgs,
-		sql: optimized.sql,
-		params: optimized.params
-	}), ...extras.map(async (e) => {
-		const overlaid = resolveExtra ? await resolveExtra({
-			key: e.key,
-			state,
-			ctx,
-			dateRange
-		}) : null;
-		return overlaid !== null ? { rows: overlaid } : runSQL({
-			...extraArgs,
-			sql: e.sql,
-			params: e.params
-		});
-	})]);
-	const firstRow = optRes.rows[0];
-	const totalCount = Number(firstRow?.totalCount ?? 0);
-	const totals = {
-		clicks: Number(firstRow?.totalClicks ?? 0),
-		impressions: Number(firstRow?.totalImpressions ?? 0),
-		ctr: Number(firstRow?.totalCtr ?? 0),
-		position: Number(firstRow?.totalPosition ?? 0)
-	};
-	return {
-		rows: optRes.rows.map((r) => {
-			const { totalCount: _tc, totalClicks: _tcl, totalImpressions: _ti, totalCtr: _tr, totalPosition: _tp, ...rest } = r;
-			for (const key of Object.keys(rest)) if (key.startsWith("__order_")) delete rest[key];
-			return rest;
-		}),
-		totalCount,
-		totals,
-		extras: extras.map((e, i) => ({
-			key: e.key,
-			rows: extrasRows[i].rows
-		})),
-		source,
-		...extraSource ? { extraSource } : {}
-	};
-}
-async function runComparisonQuery(runSQL, ctx, current, previous, windows, filter, options = {}) {
-	const probe = createParquetResolverAdapter();
-	const maxWindowEnd = windows.current.endDate > windows.previous.endDate ? windows.current.endDate : windows.previous.endDate;
-	const currentSource = decideCanonicalSource(current, probe.capabilities, options, maxWindowEnd);
-	const previousSource = decideCanonicalSource(previous, probe.capabilities, options, maxWindowEnd);
-	const startDate = windows.current.startDate < windows.previous.startDate ? windows.current.startDate : windows.previous.startDate;
-	const endDate = windows.current.endDate > windows.previous.endDate ? windows.current.endDate : windows.previous.endDate;
-	const comparisonRange = {
-		startDate,
-		endDate
-	};
-	const source = currentSource.kind === "canonical-rollup" && previousSource.kind === "canonical-rollup" ? querySourceDecision("canonical-rollup") : decidePrimarySource(options, comparisonRange, [...sourceFallbacks(currentSource), ...sourceFallbacks(previousSource)]);
-	const useCanonicalSource = source.kind === "canonical-rollup";
-	const adapter = useCanonicalSource ? createParquetResolverAdapter({ queryCanonicalSource: "column" }) : probe;
-	const comparison = resolveComparisonSQL(current, previous, {
-		adapter,
-		siteId: void 0
-	}, filter);
-	const totals = buildTotalsSql(current, {
-		adapter,
-		siteId: void 0
-	});
-	const partitions = enumeratePartitions(startDate, endDate);
-	const base = withQueryDimFileSet(useCanonicalSource ? {
-		...runArgs(ctx, partitions),
-		fileSets: { FILES: {
-			table: ctx.table,
-			keys: options.canonicalSource.keys
-		} }
-	} : source.kind === "primary-columnar" ? primaryRunArgs(ctx, options.primarySource.keys) : runArgs(ctx, partitions), canonicalQueryDim(options), !useCanonicalSource && (canonicalFeatureRequested(current, probe.capabilities) || canonicalFeatureRequested(previous, probe.capabilities)));
-	const main = await runSQL({
-		...base,
-		sql: comparison.sql,
-		params: comparison.params
-	});
-	const count = await runSQL({
-		...base,
-		sql: comparison.countSql,
-		params: comparison.countParams
-	});
-	const totalsRow = await runSQL({
-		...base,
-		sql: totals.sql,
-		params: totals.params
-	});
-	return {
-		rows: main.rows,
-		totalCount: Number(count.rows[0]?.total ?? 0),
-		totals: totalsRow.rows[0] ?? {},
-		source
-	};
-}
-function assertSchemaInSync(options) {
-	const { label, schema, tableKeyToName, mode } = options;
-	for (const [key, table] of Object.entries(schema)) {
-		const sourceCols = SCHEMAS[tableKeyToName(key)].columns.map((c) => c.name).sort();
-		const drizzleCols = Object.keys(table[Symbol.for("drizzle:Columns")] ?? {}).sort();
-		const missing = sourceCols.filter((c) => !drizzleCols.includes(c));
-		const extra = mode === "exact" ? drizzleCols.filter((c) => !sourceCols.includes(c)) : [];
-		if (missing.length > 0 || extra.length > 0) throw new Error(`${label} drizzle schema for '${key}' drifted from SCHEMAS. Missing: [${missing.join(", ")}]. Extra: [${extra.join(", ")}].`);
-	}
-}
-export { DIMENSION_SURFACES, LOGICAL_DATASETS, QuerySourceCoverageError, UnresolvableDatasetError, assertDimensionsSupported, assertSchemaInSync, buildExtrasQueries, buildTotalsSql, canonicalRollupCovers, createIcebergResolverAdapter, createParquetResolverAdapter, createR2SqlResolverAdapter, createResolverAdapter, createRollupExtrasOverlay, createSqlFragments, dimensionColumn, dimensionValue, getDimensionFilters, getFilterDimensions, getInternalFilters, inferLogicalDataset, isDatasetResolvable, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, mergeExtras, metricValue, pgResolverAdapter, resolveComparisonSQL, resolveToSQL, resolveToSQLOptimized, runComparisonQuery, runOptimizedQuery, supportsDimensionOnSurface };