@gscdump/engine 0.11.5 → 0.12.0

package/dist/_chunks/pg-adapter.mjs

@@ -1,667 +0,0 @@
-import { u as drizzleSchema } from "./schema.mjs";
-import { escapeLike } from "../sql-fragments.mjs";
-import { buildLogicalComparisonPlan, buildLogicalPlan } from "gscdump/query/plan";
-import { PgDialect } from "drizzle-orm/pg-core";
-import { sql } from "drizzle-orm";
-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`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;
-	}
-	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;
-	});
-}
-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 pgDialect = new PgDialect();
-function compilePg(query) {
-	const compiled = pgDialect.sqlToQuery(query);
-	return {
-		sql: compiled.sql,
-		params: compiled.params
-	};
-}
-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}"`)
-	});
-}
-export { DIMENSION_SURFACES as a, dimensionColumn as c, buildExtrasQueries as d, buildTotalsSql as f, resolveToSQLOptimized as g, resolveToSQL as h, createSqlFragments as i, inferLogicalDataset as l, resolveComparisonSQL as m, pgResolverAdapter as n, LOGICAL_DATASETS as o, mergeExtras as p, createResolverAdapter as r, assertDimensionsSupported as s, createParquetResolverAdapter as t, supportsDimensionOnSurface as u };