@gscdump/engine 0.6.1 → 0.6.3

package/dist/resolver/index.mjs

@@ -1,632 +1,6 @@
-import { sql } from "drizzle-orm";
-import { buildLogicalComparisonPlan, buildLogicalPlan } from "gscdump/query/plan";
-import { PgDialect, date, doublePrecision, getTableConfig, integer, pgTable, varchar } from "drizzle-orm/pg-core";
-import { SQLiteAsyncDialect } from "drizzle-orm/sqlite-core";
+import { t as SCHEMAS } from "../_chunks/schema.mjs";
+import { _ as resolveToSQL, a as createResolverAdapter, c as LOGICAL_DATASETS, d as inferLogicalDataset, f as supportsDimensionOnSurface, g as resolveComparisonSQL, h as mergeExtras, i as compileSqlite, l as assertDimensionsSupported, m as buildTotalsSql, n as pgResolverAdapter, o as createSqlFragments, p as buildExtrasQueries, r as compilePg, s as DIMENSION_SURFACES, t as createParquetResolverAdapter, u as dimensionColumn, v as resolveToSQLOptimized } from "../_chunks/pg-adapter.mjs";
 import { normalizeUrl } from "gscdump/normalize";
-function escapeLike(value) {
-	return value.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-}
-const DIMENSION_SURFACES = {
-	page: ["api", "stored"],
-	query: ["api", "stored"],
-	queryCanonical: ["stored", "derived"],
-	country: ["api", "stored"],
-	device: ["api", "stored"],
-	searchAppearance: ["api", "stored"],
-	date: ["api", "stored"]
-};
-const LOGICAL_DATASETS = {
-	pages: { dimensions: {
-		page: {
-			column: "url",
-			surfaces: ["api", "stored"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	keywords: { dimensions: {
-		query: {
-			column: "query",
-			surfaces: ["api", "stored"]
-		},
-		queryCanonical: {
-			column: "query_canonical",
-			surfaces: ["stored", "derived"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	page_keywords: { dimensions: {
-		page: {
-			column: "url",
-			surfaces: ["api", "stored"]
-		},
-		query: {
-			column: "query",
-			surfaces: ["api", "stored"]
-		},
-		queryCanonical: {
-			column: "query_canonical",
-			surfaces: ["stored", "derived"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	countries: { dimensions: {
-		country: {
-			column: "country",
-			surfaces: ["api", "stored"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	devices: { dimensions: {
-		device: {
-			column: "device",
-			surfaces: ["api", "stored"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} },
-	search_appearance: { dimensions: {
-		searchAppearance: {
-			column: "searchAppearance",
-			surfaces: ["api", "stored"]
-		},
-		date: {
-			column: "date",
-			surfaces: ["api", "stored"]
-		}
-	} }
-};
-function inferLogicalDataset(dimensions, filterDims = []) {
-	const allDims = new Set([...dimensions, ...filterDims]);
-	const has = (d) => allDims.has(d);
-	if (has("searchAppearance")) return "search_appearance";
-	if (has("page") && (has("query") || has("queryCanonical"))) return "page_keywords";
-	if (has("query") || has("queryCanonical")) return "keywords";
-	if (has("page")) return "pages";
-	if (has("country")) return "countries";
-	if (has("device")) return "devices";
-	return "keywords";
-}
-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"
-];
-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, urlToPathExpr: urlToPathExprOverride, tableRef: tableRefOverride } = 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 = []) {
-		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 dateColRef(tableKey) {
-		return colRef(tableKey, "date");
-	}
-	function siteIdColRef(tableKey) {
-		return colRef(tableKey, "site_id");
-	}
-	function dimExprSql(dim, tableKey) {
-		const colName = dimColumn(dim, tableKey);
-		if (dim === "page") return sql.raw(urlToPathExpr(colName));
-		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 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 cRef = colRef(tableKey, dimColumn(f.dimension, tableKey));
-			const matchExpr = f.dimension === "page" ? dimExprSql(f.dimension, tableKey) : 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`${cRef} LIKE ${`%${escapeLike(f.expression)}%`} ESCAPE '\\'`);
-					break;
-				case "notContains":
-					preds.push(sql`${cRef} NOT LIKE ${`%${escapeLike(f.expression)}%`} ESCAPE '\\'`);
-					break;
-				case "includingRegex":
-					preds.push(regexPredicate(cRef, f.expression, false));
-					break;
-				case "excludingRegex":
-					preds.push(regexPredicate(cRef, 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,
-		dateColRef,
-		siteIdColRef: includeSiteId ? siteIdColRef : void 0,
-		dimExprSql,
-		metricSql,
-		havingPredicates,
-		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,
-		dateColRef: runtime.dateColRef,
-		urlToPathExpr: runtime.urlToPathExpr,
-		siteIdColRef: runtime.siteIdColRef,
-		dimExprSql: runtime.dimExprSql,
-		metricSql: runtime.metricSql,
-		dimensionPredicates: runtime.dimensionPredicates,
-		havingPredicates: runtime.havingPredicates,
-		topLevelPredicate: runtime.topLevelPredicate,
-		compile: config.compile
-	};
-}
-const COMPARISON_FILTER_SQL = {
-	new: sql`AND (p.impressions IS NULL OR p.impressions = 0)`,
-	lost: sql`AND p.impressions > 0 AND c.impressions = 0`,
-	improving: sql`AND c.clicks > COALESCE(p.clicks, 0)`,
-	declining: sql`AND c.clicks < p.clicks AND p.clicks > 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`, `);
-}
-function orderByClause(state, prefix = "") {
-	if (state.orderBy) {
-		const safeCol = 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 } = options;
-	const plan = buildLogicalPlan(state, adapter.capabilities);
-	const tableKey = adapter.tableKeyForDataset(plan.dataset);
-	const dimFilters = toInternalDimensionFilters(plan.dimensionFilters);
-	const metricFilters = toInternalMetricFilters(plan.metricFilters);
-	const groupByDims = plan.groupByDimensions;
-	const hasDate = plan.hasDate;
-	const metrics = plan.metrics;
-	const wherePredicates = [];
-	if (adapter.siteIdColRef && siteId != null) wherePredicates.push(sql`${adapter.siteIdColRef(tableKey)} = ${siteId}`);
-	wherePredicates.push(sql`${adapter.dateColRef(tableKey)} >= ${plan.dateRange.startDate}`);
-	wherePredicates.push(sql`${adapter.dateColRef(tableKey)} <= ${plan.dateRange.endDate}`);
-	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
-	};
-}
-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) {
-	const { adapter } = options;
-	const { tableKey, groupByDims, hasDate, metrics, wherePredicates, having } = buildScope(state, options);
-	const table = adapter.tableRef(tableKey);
-	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`SUM(${t.clicks}) as clicks`);
-	cteSelect.push(sql`SUM(${t.impressions}) as impressions`);
-	cteSelect.push(sql`SUM(${t.sum_position}) 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("SUM(clicks) OVER() as totalClicks"));
-			break;
-		case "impressions":
-			outerSelect.push(sql.raw("impressions"));
-			outerTotals.push(sql.raw("SUM(impressions) OVER() 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;
-	}
-	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)} ${limitOffsetClause(state)}`);
-}
-function resolveToSQL(state, options) {
-	const { adapter } = options;
-	const { tableKey, groupByDims, hasDate, metrics, wherePredicates, having } = buildScope(state, options);
-	const table = adapter.tableRef(tableKey);
-	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) {
-	const { adapter } = options;
-	const { tableKey, metrics, wherePredicates } = buildScope(state, options);
-	const table = adapter.tableRef(tableKey);
-	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 } = 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.tableRef(tableKey);
-	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 (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, "c.");
-	const limitSql = limitOffsetClause(current);
-	const outerCurrentCols = [];
-	for (const d of groupByDims) {
-		const colName = d.replace(/\W/g, "");
-		outerCurrentCols.push(sql.raw(`c.${colName} as "${colName}"`));
-	}
-	outerCurrentCols.push(sql.raw("CAST(c.clicks AS DOUBLE) as \"clicks\""));
-	outerCurrentCols.push(sql.raw("CAST(c.impressions AS DOUBLE) as \"impressions\""));
-	outerCurrentCols.push(sql.raw("c.ctr as \"ctr\""));
-	outerCurrentCols.push(sql.raw("c.position 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 LEFT JOIN previous p ON ${joinOn} WHERE 1=1 ${filterClause} ${orderSql} ${limitSql}`;
-	const firstGroupBy = groupByDims[0] ? groupByDims[0].replace(/\W/g, "") : "clicks";
-	const countInnerSelect = sql.raw(`c.${firstGroupBy}`);
-	const countQuery = sql`WITH current AS (${currentCte}), previous AS (${previousCte}) SELECT COUNT(*) as total FROM (SELECT ${countInnerSelect} FROM current c LEFT 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 } = options;
-	const plan = buildLogicalPlan(state, adapter.capabilities);
-	const dims = plan.groupByDimensions;
-	const extras = [];
-	if (!dims.includes("queryCanonical")) return extras;
-	const keywordsKey = adapter.tableKeyForDataset("keywords");
-	const t = adapter.schema[keywordsKey];
-	const table = adapter.tableRef(keywordsKey);
-	const whereParts = [];
-	if (adapter.siteIdColRef && siteId != null) whereParts.push(sql`${adapter.siteIdColRef(keywordsKey)} = ${siteId}`);
-	whereParts.push(sql`${adapter.dateColRef(keywordsKey)} >= ${plan.dateRange.startDate}`);
-	whereParts.push(sql`${adapter.dateColRef(keywordsKey)} <= ${plan.dateRange.endDate}`);
-	const whereExpr = whereParts.length > 0 ? sql`WHERE ${joinAnd(whereParts)}` : sql``;
-	const outerQueryCol = sql.raw("query");
-	const compiled = compileCollapsed(adapter, sql`WITH per_variant AS (SELECT ${t.query_canonical} 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 ${t.query_canonical} ORDER BY SUM(${t.clicks}) DESC) as rn, COUNT(*) OVER (PARTITION BY ${t.query_canonical}) as variantCount FROM ${table} ${whereExpr} GROUP BY ${t.query_canonical}, ${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 = [];
-	for (const { key, results } of extrasResults) {
-		if (key === "canonicalExtras") {
-			const variantCountMap = /* @__PURE__ */ new Map();
-			const variantsMap = /* @__PURE__ */ new Map();
-			const canonicalNameMap = /* @__PURE__ */ new Map();
-			for (const r of results) {
-				const jk = String(r.joinKey);
-				variantCountMap.set(jk, r.variantCount);
-				canonicalNameMap.set(jk, r.canonicalName);
-				const raw = r.variants;
-				variantsMap.set(jk, typeof raw === "string" ? raw.split("||").filter(Boolean).map((v) => {
-					const parts = v.split(":::");
-					return {
-						query: parts[0],
-						clicks: Number(parts[1] || 0),
-						impressions: Number(parts[2] || 0),
-						position: Number(parts[3] || 0)
-					};
-				}) : []);
-			}
-			lookups.push({
-				key: "variantCount",
-				map: variantCountMap
-			});
-			lookups.push({
-				key: "variants",
-				map: variantsMap
-			});
-			lookups.push({
-				key: "canonicalName",
-				map: canonicalNameMap
-			});
-			continue;
-		}
-		const filtered = results.filter((r) => r.rn === void 0 || r.rn === 1);
-		const map = /* @__PURE__ */ new Map();
-		for (const r of filtered) {
-			let val = r[key];
-			if (key === "variants" && typeof val === "string") val = val.split("||").filter(Boolean).map((v) => {
-				const parts = v.split(":::");
-				return {
-					query: parts[0],
-					clicks: Number(parts[1] || 0),
-					impressions: Number(parts[2] || 0),
-					position: Number(parts[3] || 0)
-				};
-			});
-			map.set(String(r.joinKey), val);
-		}
-		lookups.push({
-			key,
-			map
-		});
-	}
-	return rows.map((row) => {
-		const enriched = { ...row };
-		for (const { key, map } of lookups) {
-			let joinValue;
-			if (key === "variantCount" || key === "variants" || key === "canonicalName") joinValue = String(row.queryCanonical ?? row.query_canonical ?? "");
-			enriched[key] = (joinValue && map.get(joinValue)) ?? (key === "variants" ? [] : null);
-			if (key === "canonicalName" && enriched[key]) enriched.queryCanonical = enriched[key];
-		}
-		return enriched;
-	});
-}
 function createSqlQuerySource(options) {
 	const { name, adapter, execute, siteId, extraCapabilities } = options;
 	return {
@@ -647,22 +21,6 @@ function createSqlQuerySource(options) {
 		}
 	};
 }
-const pgDialect = new PgDialect();
-const sqliteDialect = new SQLiteAsyncDialect();
-function compilePg(query) {
-	const compiled = pgDialect.sqlToQuery(query);
-	return {
-		sql: compiled.sql,
-		params: compiled.params
-	};
-}
-function compileSqlite(query) {
-	const compiled = sqliteDialect.sqlToQuery(query);
-	return {
-		sql: compiled.sql,
-		params: compiled.params
-	};
-}
 function collectInternalFilters(filter) {
 	if (!filter || !("_filters" in filter)) return [];
 	const flat = filter._filters;
@@ -717,142 +75,6 @@ function matchesMetricFilter(row, filter) {
 function matchesTopLevelPage(row) {
 	return (normalizeUrl(dimensionValue(row, "page")).match(/\//g)?.length ?? 0) <= 1;
 }
-function metricCols() {
-	return {
-		clicks: integer("clicks").notNull(),
-		impressions: integer("impressions").notNull(),
-		sum_position: doublePrecision("sum_position").notNull()
-	};
-}
-const dateCol = () => date("date").notNull();
-const drizzleSchema = {
-	pages: pgTable("pages", {
-		url: varchar("url").notNull(),
-		date: dateCol(),
-		...metricCols()
-	}),
-	keywords: pgTable("keywords", {
-		query: varchar("query").notNull(),
-		query_canonical: varchar("query_canonical"),
-		date: dateCol(),
-		...metricCols()
-	}),
-	countries: pgTable("countries", {
-		country: varchar("country").notNull(),
-		date: dateCol(),
-		...metricCols()
-	}),
-	devices: pgTable("devices", {
-		device: varchar("device").notNull(),
-		date: dateCol(),
-		...metricCols()
-	}),
-	page_keywords: pgTable("page_keywords", {
-		url: varchar("url").notNull(),
-		query: varchar("query").notNull(),
-		query_canonical: varchar("query_canonical"),
-		date: dateCol(),
-		...metricCols()
-	}),
-	search_appearance: pgTable("search_appearance", {
-		searchAppearance: varchar("searchAppearance").notNull(),
-		date: dateCol(),
-		...metricCols()
-	})
-};
-const TABLE_METADATA = {
-	pages: {
-		sortKey: ["date", "url"],
-		version: 1
-	},
-	keywords: {
-		sortKey: ["date", "query"],
-		version: 2
-	},
-	countries: {
-		sortKey: ["date", "country"],
-		version: 1
-	},
-	devices: {
-		sortKey: ["date", "device"],
-		version: 1
-	},
-	page_keywords: {
-		sortKey: [
-			"date",
-			"url",
-			"query"
-		],
-		version: 2
-	},
-	search_appearance: {
-		sortKey: ["date", "searchAppearance"],
-		version: 1
-	}
-};
-const PG_BASE_CONFIG = {
-	schema: drizzleSchema,
-	datasetToTableKey: {
-		pages: "pages",
-		keywords: "keywords",
-		page_keywords: "page_keywords",
-		countries: "countries",
-		devices: "devices",
-		search_appearance: "search_appearance"
-	},
-	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() {
-	return createResolverAdapter({
-		...PG_BASE_CONFIG,
-		tableLabel: "parquet-resolver-adapter",
-		tableRef: (tk) => sql.raw(`read_parquet({{FILES}}, union_by_name = true) AS "${tk}"`)
-	});
-}
-function pgSqlTypeToColumnType(sqlType) {
-	const t = sqlType.toLowerCase();
-	if (t.startsWith("varchar") || t === "text" || t.startsWith("char")) return "VARCHAR";
-	if (t === "date" || t.startsWith("timestamp")) return "DATE";
-	if (t.startsWith("double") || t === "real" || t.startsWith("numeric") || t.startsWith("decimal")) return "DOUBLE";
-	if (t === "bigint" || t === "int8") return "BIGINT";
-	if (t === "integer" || t === "int" || t === "int4" || t === "smallint" || t === "int2") return "INTEGER";
-	throw new Error(`unmapped pg type '${sqlType}' — extend pgSqlTypeToColumnType in @gscdump/engine/schema`);
-}
-function tableSchemaFrom(tableName) {
-	const columns = getTableConfig(drizzleSchema[tableName]).columns.map((col) => ({
-		name: col.name,
-		type: pgSqlTypeToColumnType(col.getSQLType()),
-		nullable: !col.notNull
-	}));
-	const meta = TABLE_METADATA[tableName];
-	return {
-		name: tableName,
-		columns,
-		sortKey: meta.sortKey,
-		version: meta.version
-	};
-}
-const SCHEMAS = Object.fromEntries([
-	"pages",
-	"keywords",
-	"countries",
-	"devices",
-	"page_keywords",
-	"search_appearance"
-].map((t) => [t, tableSchemaFrom(t)]));
 function assertSchemaInSync(options) {
 	const { label, schema, tableKeyToName, mode } = options;
 	for (const [key, table] of Object.entries(schema)) {