@gscdump/analysis 1.4.0 → 1.4.1

package/dist/analyzers/concentration.d.mts

@@ -0,0 +1,42 @@
+import { PageRow, QueriesRow } from "../types.mjs";
+type ConcentrationRiskLevel = 'low' | 'medium' | 'high';
+interface ConcentrationOptions {
+  /** Number of top items to report. Default: 10 */
+  topN?: number;
+}
+interface ConcentrationItem {
+  key: string;
+  clicks: number;
+  share: number;
+}
+interface ConcentrationInput {
+  key: string;
+  clicks: number;
+}
+interface ConcentrationResult {
+  /** Gini coefficient: 0 = equal distribution, 1 = fully concentrated */
+  giniCoefficient: number;
+  /** Herfindahl-Hirschman Index: 0-10000, >2500 = highly concentrated */
+  hhi: number;
+  /** Percentage of total clicks from top N items */
+  topNConcentration: number;
+  topNItems: ConcentrationItem[];
+  totalItems: number;
+  totalClicks: number;
+  /** Risk level derived from HHI: <1500 low, 1500-2500 medium, >2500 high */
+  riskLevel: ConcentrationRiskLevel;
+}
+/**
+ * Pure helper: analyze traffic concentration across items (pages or keywords).
+ * Re-exported from `@gscdump/analysis` for portable callers.
+ */
+declare function analyzeConcentration(items: ConcentrationInput[], options?: ConcentrationOptions): ConcentrationResult;
+/**
+ * Page concentration analysis.
+ */
+declare function analyzePageConcentration(pages: PageRow[], options?: ConcentrationOptions): ConcentrationResult;
+/**
+ * Keyword concentration analysis.
+ */
+declare function analyzeKeywordConcentration(keywords: QueriesRow[], options?: ConcentrationOptions): ConcentrationResult;
+export { ConcentrationInput, ConcentrationItem, ConcentrationOptions, ConcentrationResult, ConcentrationRiskLevel, analyzeConcentration, analyzeKeywordConcentration, analyzePageConcentration };

package/dist/analyzers/concentration.mjs

@@ -0,0 +1,180 @@
+import { parseJsonRows, rowString } from "../analyzer/row-values.mjs";
+import { pagesQueryState, queriesQueryState } from "../analyzer/adapt-rows.mjs";
+import { defineAnalyzer } from "@gscdump/engine/analyzer";
+import { periodOf } from "@gscdump/engine/period";
+import { enumeratePartitions } from "@gscdump/engine/planner";
+import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
+import { num } from "@gscdump/engine/analysis-types";
+function analyzeConcentration(items, options = {}) {
+	const { topN = 10 } = options;
+	if (items.length === 0) return {
+		giniCoefficient: 0,
+		hhi: 0,
+		topNConcentration: 0,
+		topNItems: [],
+		totalItems: 0,
+		totalClicks: 0,
+		riskLevel: "low"
+	};
+	const sorted = [...items].sort((a, b) => b.clicks - a.clicks);
+	const n = sorted.length;
+	let totalClicks = 0;
+	let squaredClicks = 0;
+	let weightedSum = 0;
+	for (let i = 0; i < n; i++) {
+		const clicks = sorted[i].clicks;
+		totalClicks += clicks;
+		squaredClicks += clicks * clicks;
+		weightedSum += (n - 2 * i - 1) * clicks;
+	}
+	const giniCoefficient = totalClicks === 0 ? 0 : weightedSum / (n * totalClicks);
+	const hhi = totalClicks > 0 ? squaredClicks / (totalClicks * totalClicks) * 1e4 : 0;
+	const topNItems = sorted.slice(0, topN).map((item) => ({
+		key: item.key,
+		clicks: item.clicks,
+		share: totalClicks > 0 ? item.clicks / totalClicks : 0
+	}));
+	const topNClicks = topNItems.reduce((sum, item) => sum + item.clicks, 0);
+	const topNConcentration = totalClicks > 0 ? topNClicks / totalClicks : 0;
+	let riskLevel = "low";
+	if (hhi > 2500) riskLevel = "high";
+	else if (hhi > 1500) riskLevel = "medium";
+	return {
+		giniCoefficient,
+		hhi,
+		topNConcentration,
+		topNItems,
+		totalItems: items.length,
+		totalClicks,
+		riskLevel
+	};
+}
+function analyzePageConcentration(pages, options) {
+	return analyzeConcentration(pages.map((p) => ({
+		key: p.page,
+		clicks: num(p.clicks)
+	})), options);
+}
+function analyzeKeywordConcentration(keywords, options) {
+	return analyzeConcentration(keywords.map((k) => ({
+		key: k.query,
+		clicks: num(k.clicks)
+	})), options);
+}
+const concentrationAnalyzer = defineAnalyzer({
+	id: "concentration",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		const dim = params.dimension || "pages";
+		const topN = params.topN ?? 10;
+		const table = dim === "keywords" ? "queries" : "pages";
+		const keyCol = dim === "keywords" ? "query" : "url";
+		return {
+			sql: `
+    WITH items AS (
+      SELECT
+        ${keyCol} AS key,
+        ${METRIC_EXPR.clicks} AS clicks
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+      GROUP BY ${keyCol}
+      HAVING SUM(clicks) > 0
+    ),
+    totals AS (
+      SELECT SUM(clicks) AS total_clicks, COUNT(*) AS total_items FROM items
+    ),
+    ranked AS (
+      SELECT
+        i.key, i.clicks,
+        i.clicks / NULLIF(t.total_clicks, 0) AS share,
+        ROW_NUMBER() OVER (ORDER BY i.clicks DESC, i.key ASC) AS rnk_desc,
+        ROW_NUMBER() OVER (ORDER BY i.clicks ASC, i.key ASC) AS rnk_asc,
+        t.total_clicks AS tclicks,
+        t.total_items AS titems
+      FROM items i, totals t
+    ),
+    gini_num AS (
+      SELECT SUM((2.0 * rnk_asc - titems - 1) * clicks) AS weighted_sum FROM ranked
+    ),
+    hhi_calc AS (
+      SELECT SUM(POWER(share * 100, 2)) AS hhi FROM ranked
+    ),
+    top_list AS (
+      SELECT
+        list({ 'key': key, 'clicks': clicks, 'share': share } ORDER BY clicks DESC, key ASC) AS items,
+        SUM(clicks) AS top_clicks
+      FROM ranked WHERE rnk_desc <= ?
+    )
+    SELECT
+      COALESCE(
+        (SELECT weighted_sum FROM gini_num)
+          / NULLIF((SELECT total_items FROM totals) * (SELECT total_clicks FROM totals), 0),
+        0.0
+      ) AS giniCoefficient,
+      COALESCE((SELECT hhi FROM hhi_calc), 0.0) AS hhi,
+      COALESCE(
+        CAST((SELECT top_clicks FROM top_list) AS DOUBLE)
+          / NULLIF((SELECT total_clicks FROM totals), 0),
+        0.0
+      ) AS topNConcentration,
+      COALESCE((SELECT to_json(items) FROM top_list), '[]') AS topNItems,
+      COALESCE((SELECT total_items FROM totals), 0) AS totalItems,
+      COALESCE((SELECT total_clicks FROM totals), 0.0) AS totalClicks,
+      CASE
+        WHEN COALESCE((SELECT hhi FROM hhi_calc), 0.0) > 2500 THEN 'high'
+        WHEN COALESCE((SELECT hhi FROM hhi_calc), 0.0) > 1500 THEN 'medium'
+        ELSE 'low'
+      END AS riskLevel
+  `,
+			params: [
+				startDate,
+				endDate,
+				topN
+			],
+			current: {
+				table,
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const r = (Array.isArray(rows) ? rows : [])[0] ?? {};
+		const topRaw = parseJsonRows(r.topNItems);
+		return {
+			results: [{
+				giniCoefficient: num(r.giniCoefficient),
+				hhi: num(r.hhi),
+				topNConcentration: num(r.topNConcentration),
+				topNItems: topRaw.map((t) => ({
+					key: rowString(t.key),
+					clicks: num(t.clicks),
+					share: num(t.share)
+				})),
+				totalItems: num(r.totalItems),
+				totalClicks: num(r.totalClicks),
+				riskLevel: rowString(r.riskLevel)
+			}],
+			meta: {
+				total: 1,
+				dimension: params.dimension || "pages"
+			}
+		};
+	},
+	buildRows(params) {
+		const dim = params.dimension || "pages";
+		const period = periodOf(params);
+		const out = {};
+		if (dim === "pages") out.pages = pagesQueryState(period, params.limit);
+		else out.queries = queriesQueryState(period, params.limit);
+		return out;
+	},
+	reduceRows(rows, params) {
+		const dim = params.dimension || "pages";
+		const arr = Array.isArray(rows) ? rows : rows[dim === "pages" ? "pages" : "queries"] ?? [];
+		return {
+			results: [dim === "pages" ? analyzePageConcentration(arr, { topN: params.topN }) : analyzeKeywordConcentration(arr, { topN: params.topN })],
+			meta: { dimension: dim }
+		};
+	}
+});
+export { analyzeConcentration, analyzeKeywordConcentration, analyzePageConcentration, concentrationAnalyzer };

package/dist/analyzers/content-velocity.mjs

@@ -0,0 +1,87 @@
+import { rowNumber, rowString } from "../analyzer/row-values.mjs";
+import { defineAnalyzer } from "@gscdump/engine/analyzer";
+import { periodOf } from "@gscdump/engine/period";
+import { enumeratePartitions } from "@gscdump/engine/planner";
+import { toIsoDate } from "gscdump/dates";
+const contentVelocityAnalyzer = defineAnalyzer({
+	id: "content-velocity",
+	buildSql(params) {
+		const days = Math.min(Math.max(Number(params.days ?? 90), 7), 365);
+		const { endDate } = periodOf(params);
+		const start = new Date(endDate);
+		start.setUTCDate(start.getUTCDate() - days);
+		const startDate = toIsoDate(start);
+		return {
+			sql: `
+    WITH src AS (
+      SELECT query, date
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+    ),
+    first_seen AS (
+      SELECT query, MIN(date) AS first_date FROM src GROUP BY query
+    ),
+    per_week AS (
+      SELECT
+        strftime(CAST(date AS DATE), '%G-W%V') AS week,
+        MIN(date) AS week_start,
+        CAST(COUNT(DISTINCT query) AS DOUBLE) AS totalKeywords
+      FROM src
+      GROUP BY week
+    ),
+    new_per_week AS (
+      SELECT
+        strftime(CAST(first_date AS DATE), '%G-W%V') AS week,
+        CAST(COUNT(*) AS DOUBLE) AS newKeywords
+      FROM first_seen
+      GROUP BY week
+    )
+    SELECT
+      pw.week AS week,
+      COALESCE(npw.newKeywords, 0) AS newKeywords,
+      pw.totalKeywords AS totalKeywords
+    FROM per_week pw
+    LEFT JOIN new_per_week npw ON pw.week = npw.week
+    ORDER BY pw.week ASC
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "queries",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const days = Math.min(Math.max(Number(params.days ?? 90), 7), 365);
+		const { endDate } = periodOf(params);
+		const startDateD = new Date(endDate);
+		startDateD.setUTCDate(startDateD.getUTCDate() - days);
+		const startDate = toIsoDate(startDateD);
+		const weekly = arr.map((r) => ({
+			week: rowString(r.week),
+			newKeywords: rowNumber(r.newKeywords),
+			totalKeywords: rowNumber(r.totalKeywords)
+		}));
+		const total = weekly.reduce((s, w) => s + w.newKeywords, 0);
+		const avg = weekly.length > 0 ? total / weekly.length : 0;
+		const mid = Math.floor(weekly.length / 2);
+		const firstAvg = mid > 0 ? weekly.slice(0, mid).reduce((s, w) => s + w.newKeywords, 0) / mid : 0;
+		const diff = (weekly.length - mid > 0 ? weekly.slice(mid).reduce((s, w) => s + w.newKeywords, 0) / (weekly.length - mid) : 0) - firstAvg;
+		const threshold = Math.max(1, avg * .15);
+		return {
+			results: weekly,
+			meta: {
+				summary: {
+					totalNewKeywords: total,
+					avgPerWeek: avg,
+					trend: diff > threshold ? "accelerating" : diff < -threshold ? "decelerating" : "stable"
+				},
+				days,
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+export { contentVelocityAnalyzer };

package/dist/analyzers/ctr-anomaly.mjs

@@ -0,0 +1,189 @@
+import { parseJsonRows, rowBoolean, rowNumber, rowString } from "../analyzer/row-values.mjs";
+import { defineAnalyzer } from "@gscdump/engine/analyzer";
+import { defaultEndDate } from "@gscdump/engine/period";
+import { enumeratePartitions } from "@gscdump/engine/planner";
+import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
+import { daysAgoUtc } from "gscdump/dates";
+const ctrAnomalyAnalyzer = defineAnalyzer({
+	id: "ctr-anomaly",
+	buildSql(params) {
+		const endDate = params.endDate ?? defaultEndDate();
+		const startDate = params.startDate ?? daysAgoUtc(93);
+		const minDailyImpressions = params.minImpressions ?? 5;
+		const minRollingN = 14;
+		const zThreshold = params.threshold ?? 2;
+		const maxPositionDelta = 1.5;
+		const minBreachDays = 2;
+		const limit = params.limit ?? 200;
+		return {
+			sql: `
+    WITH daily AS (
+      SELECT
+        query,
+        url AS page,
+        -- Normalize at the source CTE: union_by_name=true can coerce date to
+        -- VARCHAR across parquets with mixed schemas, which makes downstream
+        -- strftime(date, ...) binder-error.
+        CAST(date AS DATE) AS date,
+        ${METRIC_EXPR.clicks} AS day_clicks,
+        ${METRIC_EXPR.impressions} AS day_impressions,
+        ${METRIC_EXPR.ctr} AS day_ctr,
+        ${METRIC_EXPR.position} AS day_position
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ?
+        AND query IS NOT NULL AND query <> ''
+        AND url IS NOT NULL AND url <> ''
+      GROUP BY query, url, date
+      HAVING SUM(impressions) >= ?
+    ),
+    rolled AS (
+      SELECT *,
+        AVG(day_ctr)           OVER w AS rolling_ctr,
+        STDDEV_POP(day_ctr)    OVER w AS rolling_stddev,
+        -- Impression-weighted rolling mean: day_position is already a recovered
+        -- 1-based daily weighted mean, so weighting by day impressions directly
+        -- is algebraically exact (no -1/+1 dance needed).
+        SUM(day_position * day_impressions) OVER w
+          / NULLIF(SUM(day_impressions) OVER w, 0) AS rolling_position,
+        COUNT(*)               OVER w AS rolling_n
+      FROM daily
+      WINDOW w AS (
+        PARTITION BY query, page
+        ORDER BY date
+        ROWS BETWEEN 28 PRECEDING AND 1 PRECEDING
+      )
+    ),
+    flagged AS (
+      SELECT *,
+        CASE
+          WHEN rolling_n >= ${Number(minRollingN)} AND rolling_stddev > 0
+            THEN (day_ctr - rolling_ctr) / rolling_stddev
+          ELSE 0.0
+        END AS z_score,
+        CASE
+          WHEN rolling_position IS NULL THEN 0.0
+          ELSE ABS(day_position - rolling_position)
+        END AS position_delta
+      FROM rolled
+    ),
+    breaches AS (
+      SELECT *,
+        CASE
+          WHEN ABS(z_score) >= ${zThreshold}
+            AND position_delta <= ${maxPositionDelta}
+            AND rolling_n >= ${Number(minRollingN)}
+          THEN true ELSE false
+        END AS is_breach
+      FROM flagged
+    ),
+    per_entity AS (
+      SELECT
+        query, page,
+        COUNT(*) FILTER (WHERE is_breach AND z_score < 0) AS breach_days_down,
+        COUNT(*) FILTER (WHERE is_breach AND z_score > 0) AS breach_days_up,
+        SUM(CASE
+          WHEN is_breach AND z_score < 0
+            THEN (rolling_ctr - day_ctr) * day_impressions
+          ELSE 0.0
+        END) AS clicks_lost,
+        SUM(CASE
+          WHEN is_breach AND z_score < 0
+            THEN ABS(z_score) * day_impressions
+          ELSE 0.0
+        END) AS severity_raw,
+        MAX(CASE WHEN is_breach THEN ABS(z_score) ELSE 0.0 END) AS max_z,
+        AVG(rolling_ctr) FILTER (WHERE rolling_n >= ${Number(minRollingN)}) AS baseline_ctr,
+        SUM(rolling_position * day_impressions) FILTER (WHERE rolling_n >= ${Number(minRollingN)})
+          / NULLIF(SUM(day_impressions) FILTER (WHERE rolling_n >= ${Number(minRollingN)}), 0) AS baseline_position,
+        SUM(day_impressions) AS total_impressions,
+        SUM(day_clicks) AS total_clicks
+      FROM breaches
+      GROUP BY query, page
+      HAVING COUNT(*) FILTER (WHERE is_breach AND z_score < 0) >= ${Number(minBreachDays)}
+    ),
+    series AS (
+      SELECT query, page,
+        to_json(list({
+          'date': strftime(date, '%Y-%m-%d'),
+          'ctr': day_ctr,
+          'position': day_position,
+          'impressions': day_impressions,
+          'rollingCtr': rolling_ctr,
+          'rollingStddev': rolling_stddev,
+          'z': z_score,
+          'breach': is_breach AND z_score < 0
+        } ORDER BY date)) AS seriesJson
+      FROM breaches
+      GROUP BY query, page
+    )
+    SELECT
+      e.query AS keyword,
+      e.page,
+      CAST(e.breach_days_down AS DOUBLE) AS breachDaysDown,
+      CAST(e.breach_days_up AS DOUBLE) AS breachDaysUp,
+      CAST(ROUND(e.clicks_lost) AS DOUBLE) AS clicksLost,
+      e.severity_raw AS severityRaw,
+      e.max_z AS maxZ,
+      e.baseline_ctr AS baselineCtr,
+      e.baseline_position AS baselinePosition,
+      e.total_impressions AS totalImpressions,
+      e.total_clicks AS totalClicks,
+      s.seriesJson
+    FROM per_entity e
+    LEFT JOIN series s USING (query, page)
+    ORDER BY clicksLost DESC
+    LIMIT ${Number(limit)}
+  `,
+			params: [
+				startDate,
+				endDate,
+				minDailyImpressions
+			],
+			current: {
+				table: "page_queries",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const minRollingN = 14;
+		const zThreshold = params.threshold ?? 2;
+		const anomalies = arr.map((r) => ({
+			keyword: rowString(r.keyword),
+			page: rowString(r.page),
+			breachDaysDown: rowNumber(r.breachDaysDown),
+			breachDaysUp: rowNumber(r.breachDaysUp),
+			clicksLost: rowNumber(r.clicksLost),
+			severity: rowNumber(r.severityRaw),
+			maxZ: rowNumber(r.maxZ),
+			baselineCtr: rowNumber(r.baselineCtr),
+			baselinePosition: rowNumber(r.baselinePosition),
+			totalImpressions: rowNumber(r.totalImpressions),
+			totalClicks: rowNumber(r.totalClicks),
+			series: parseJsonRows(r.seriesJson).map((s) => ({
+				date: rowString(s.date),
+				ctr: rowNumber(s.ctr),
+				position: rowNumber(s.position),
+				impressions: rowNumber(s.impressions),
+				rollingCtr: s.rollingCtr == null ? null : rowNumber(s.rollingCtr),
+				rollingStddev: s.rollingStddev == null ? null : rowNumber(s.rollingStddev),
+				z: rowNumber(s.z),
+				breach: rowBoolean(s.breach)
+			}))
+		}));
+		const totalClicksLost = anomalies.reduce((s, a) => s + a.clicksLost, 0);
+		const totalBreachDays = anomalies.reduce((s, a) => s + a.breachDaysDown, 0);
+		return {
+			results: anomalies,
+			meta: {
+				total: anomalies.length,
+				totalClicksLost,
+				totalBreachDays,
+				zThreshold,
+				minRollingN
+			}
+		};
+	}
+});
+export { ctrAnomalyAnalyzer };

package/dist/analyzers/ctr-curve.mjs

@@ -0,0 +1,128 @@
+import { parseJsonRows, rowNumber, rowString } from "../analyzer/row-values.mjs";
+import { defineAnalyzer } from "@gscdump/engine/analyzer";
+import { periodOf } from "@gscdump/engine/period";
+import { enumeratePartitions } from "@gscdump/engine/planner";
+import { METRIC_EXPR } from "@gscdump/engine/sql-fragments";
+const ctrCurveAnalyzer = defineAnalyzer({
+	id: "ctr-curve",
+	buildSql(params) {
+		const { startDate, endDate } = periodOf(params);
+		return {
+			sql: `
+    WITH src AS (
+      SELECT
+        query,
+        clicks,
+        impressions,
+        sum_position,
+        (sum_position / NULLIF(impressions, 0) + 1) AS avg_pos
+      FROM read_parquet({{FILES}}, union_by_name = true)
+      WHERE date >= ? AND date <= ? AND impressions > 0
+    ),
+    curve AS (
+      SELECT
+        CASE
+          WHEN avg_pos <= 1.5 THEN '1'
+          WHEN avg_pos <= 2.5 THEN '2'
+          WHEN avg_pos <= 3.5 THEN '3'
+          WHEN avg_pos <= 5.5 THEN '4-5'
+          WHEN avg_pos <= 10.5 THEN '6-10'
+          WHEN avg_pos <= 20.5 THEN '11-20'
+          ELSE '20+'
+        END AS bucket,
+        AVG(CAST(clicks AS DOUBLE) / NULLIF(impressions, 0)) AS avgCtr,
+        (SUM(sum_position) / NULLIF(SUM(impressions), 0) + 1) AS medianPosition,
+        CAST(COUNT(DISTINCT query) AS DOUBLE) AS keywordCount,
+        ${METRIC_EXPR.clicks} AS totalClicks,
+        ${METRIC_EXPR.impressions} AS totalImpressions
+      FROM src
+      GROUP BY bucket
+    ),
+    ks AS (
+      SELECT
+        query,
+        ${METRIC_EXPR.clicks} AS clicks,
+        ${METRIC_EXPR.impressions} AS impressions,
+        ${METRIC_EXPR.ctr} AS ctr,
+        ${METRIC_EXPR.position} AS position,
+        CASE
+          WHEN ${METRIC_EXPR.position} <= 3.5 THEN 'top3'
+          WHEN ${METRIC_EXPR.position} <= 10.5 THEN 'page1'
+          WHEN ${METRIC_EXPR.position} <= 20.5 THEN 'page2'
+          ELSE 'deep'
+        END AS band
+      FROM src
+      GROUP BY query
+      HAVING SUM(impressions) >= 20
+    ),
+    band_avg AS (
+      SELECT band, AVG(ctr) AS band_avg_ctr FROM ks GROUP BY band
+    ),
+    outliers AS (
+      SELECT
+        ks.query, ks.clicks, ks.impressions, ks.ctr, ks.position,
+        ba.band_avg_ctr AS expectedCtr,
+        ks.ctr - ba.band_avg_ctr AS ctrDiff
+      FROM ks JOIN band_avg ba ON ks.band = ba.band
+      ORDER BY ABS(ks.ctr - ba.band_avg_ctr) DESC
+      LIMIT 50
+    )
+    SELECT
+      (SELECT to_json(list({
+        'bucket': bucket,
+        'avgCtr': avgCtr,
+        'medianPosition': medianPosition,
+        'keywordCount': keywordCount,
+        'totalClicks': totalClicks,
+        'totalImpressions': totalImpressions
+      })) FROM curve) AS curve_json,
+      (SELECT to_json(list({
+        'query': query,
+        'clicks': clicks,
+        'impressions': impressions,
+        'ctr': ctr,
+        'position': position,
+        'expectedCtr': expectedCtr,
+        'ctrDiff': ctrDiff
+      })) FROM outliers) AS outliers_json
+  `,
+			params: [startDate, endDate],
+			current: {
+				table: "queries",
+				partitions: enumeratePartitions(startDate, endDate)
+			}
+		};
+	},
+	reduceSql(rows, params) {
+		const arr = Array.isArray(rows) ? rows : [];
+		const { startDate, endDate } = periodOf(params);
+		const row = arr[0] ?? {};
+		const curve = parseJsonRows(row.curve_json).map((r) => ({
+			bucket: rowString(r.bucket),
+			avgCtr: rowNumber(r.avgCtr),
+			medianPosition: rowNumber(r.medianPosition),
+			keywordCount: rowNumber(r.keywordCount),
+			totalClicks: rowNumber(r.totalClicks),
+			totalImpressions: rowNumber(r.totalImpressions)
+		}));
+		const outliers = parseJsonRows(row.outliers_json).map((r) => ({
+			query: rowString(r.query),
+			clicks: rowNumber(r.clicks),
+			impressions: rowNumber(r.impressions),
+			ctr: rowNumber(r.ctr),
+			position: rowNumber(r.position),
+			expectedCtr: rowNumber(r.expectedCtr),
+			ctrDiff: rowNumber(r.ctrDiff)
+		}));
+		return {
+			results: curve,
+			meta: {
+				overperforming: outliers.filter((o) => o.ctrDiff > 0).slice(0, 25),
+				underperforming: outliers.filter((o) => o.ctrDiff < 0).slice(0, 25),
+				startDate,
+				endDate
+			}
+		};
+	}
+});
+export { ctrCurveAnalyzer };