theus-cli-darwin-x64 0.2.84

package/vendor/theus-arsenal/skills/patrones-clickhouse/SKILL.md

@@ -0,0 +1,443 @@
+---
+name: patrones-clickhouse
+description: Patrones de ClickHouse para analítica de alto rendimiento — diseño de tablas MergeTree, optimización de consultas, vistas materializadas, inserción masiva y pipelines de datos. Usa esta skill al diseñar esquemas OLAP o migrar analítica desde PostgreSQL/MySQL.
+---
+
+# Patrones de analítica con ClickHouse
+
+Patrones específicos de ClickHouse para analítica de alto rendimiento e ingeniería de datos.
+
+## Cuándo activarla
+
+- Al diseñar esquemas de tablas en ClickHouse (selección de motor MergeTree).
+- Al escribir consultas analíticas (agregaciones, funciones de ventana, joins).
+- Al optimizar rendimiento de consultas (poda de particiones, proyecciones, vistas materializadas).
+- Al ingerir grandes volúmenes de datos (inserciones por lotes, integración con Kafka).
+- Al migrar analítica de PostgreSQL/MySQL a ClickHouse.
+- Al implementar dashboards en tiempo real o analítica de series temporales.
+
+## Panorama
+
+ClickHouse es un sistema de base de datos orientado a columnas (DBMS) para procesamiento analítico en línea (OLAP). Está optimizado para consultas analíticas rápidas sobre datasets grandes.
+
+**Características clave:**
+- Almacenamiento orientado a columnas.
+- Compresión de datos.
+- Ejecución paralela de consultas.
+- Consultas distribuidas.
+- Analítica en tiempo real.
+
+## Patrones de diseño de tablas
+
+### Motor MergeTree (el más común)
+
+```sql
+CREATE TABLE markets_analytics (
+    date Date,
+    market_id String,
+    market_name String,
+    volume UInt64,
+    trades UInt32,
+    unique_traders UInt32,
+    avg_trade_size Float64,
+    created_at DateTime
+) ENGINE = MergeTree()
+PARTITION BY toYYYYMM(date)
+ORDER BY (date, market_id)
+SETTINGS index_granularity = 8192;
+```
+
+### ReplacingMergeTree (deduplicación)
+
+```sql
+-- Para datos que pueden traer duplicados (p. ej., de múltiples fuentes)
+CREATE TABLE user_events (
+    event_id String,
+    user_id String,
+    event_type String,
+    timestamp DateTime,
+    properties String
+) ENGINE = ReplacingMergeTree()
+PARTITION BY toYYYYMM(timestamp)
+ORDER BY (user_id, event_id, timestamp)
+PRIMARY KEY (user_id, event_id);
+```
+
+### AggregatingMergeTree (preagregación)
+
+```sql
+-- Para mantener métricas agregadas
+CREATE TABLE market_stats_hourly (
+    hour DateTime,
+    market_id String,
+    total_volume AggregateFunction(sum, UInt64),
+    total_trades AggregateFunction(count, UInt32),
+    unique_users AggregateFunction(uniq, String)
+) ENGINE = AggregatingMergeTree()
+PARTITION BY toYYYYMM(hour)
+ORDER BY (hour, market_id);
+
+-- Consultar los datos agregados
+SELECT
+    hour,
+    market_id,
+    sumMerge(total_volume) AS volume,
+    countMerge(total_trades) AS trades,
+    uniqMerge(unique_users) AS users
+FROM market_stats_hourly
+WHERE hour >= toStartOfHour(now() - INTERVAL 24 HOUR)
+GROUP BY hour, market_id
+ORDER BY hour DESC;
+```
+
+## Patrones de optimización de consultas
+
+### Filtrado eficiente
+
+```sql
+-- BIEN: usar primero las columnas indexadas
+SELECT *
+FROM markets_analytics
+WHERE date >= '2025-01-01'
+  AND market_id = 'market-123'
+  AND volume > 1000
+ORDER BY date DESC
+LIMIT 100;
+
+-- MAL: filtrar primero por columnas no indexadas
+SELECT *
+FROM markets_analytics
+WHERE volume > 1000
+  AND market_name LIKE '%election%'
+  AND date >= '2025-01-01';
+```
+
+### Agregaciones
+
+```sql
+-- BIEN: usar las funciones de agregación propias de ClickHouse
+SELECT
+    toStartOfDay(created_at) AS day,
+    market_id,
+    sum(volume) AS total_volume,
+    count() AS total_trades,
+    uniq(trader_id) AS unique_traders,
+    avg(trade_size) AS avg_size
+FROM trades
+WHERE created_at >= today() - INTERVAL 7 DAY
+GROUP BY day, market_id
+ORDER BY day DESC, total_volume DESC;
+
+-- BIEN: usar quantile para percentiles (más eficiente que percentile)
+SELECT
+    quantile(0.50)(trade_size) AS median,
+    quantile(0.95)(trade_size) AS p95,
+    quantile(0.99)(trade_size) AS p99
+FROM trades
+WHERE created_at >= now() - INTERVAL 1 HOUR;
+```
+
+### Funciones de ventana
+
+```sql
+-- Calcular totales acumulados
+SELECT
+    date,
+    market_id,
+    volume,
+    sum(volume) OVER (
+        PARTITION BY market_id
+        ORDER BY date
+        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+    ) AS cumulative_volume
+FROM markets_analytics
+WHERE date >= today() - INTERVAL 30 DAY
+ORDER BY market_id, date;
+```
+
+## Patrones de inserción de datos
+
+### Inserción masiva (recomendada)
+
+```typescript
+import { createClient } from '@clickhouse/client'
+
+const clickhouse = createClient({
+  url: process.env.CLICKHOUSE_URL ?? 'http://localhost:8123',
+  username: process.env.CLICKHOUSE_USER,
+  password: process.env.CLICKHOUSE_PASSWORD
+})
+
+// BIEN: inserción por lotes (eficiente)
+async function bulkInsertTrades(trades: Trade[]) {
+  await clickhouse.insert({
+    table: 'trades',
+    values: trades.map(trade => ({
+      id: trade.id,
+      market_id: trade.market_id,
+      user_id: trade.user_id,
+      amount: trade.amount,
+      timestamp: trade.timestamp.toISOString()
+    })),
+    format: 'JSONEachRow'
+  })
+}
+
+// MAL: inserciones individuales (lento)
+async function insertTrade(trade: Trade) {
+  // ¡No hagas esto dentro de un bucle!
+  await clickhouse.insert({
+    table: 'trades',
+    values: [{
+      id: trade.id,
+      market_id: trade.market_id,
+      user_id: trade.user_id,
+      amount: trade.amount,
+      timestamp: trade.timestamp.toISOString()
+    }],
+    format: 'JSONEachRow'
+  })
+}
+```
+
+### Inserción en streaming
+
+```typescript
+// Para ingesta continua de datos
+import { Readable } from 'node:stream'
+
+async function streamInserts(dataSource: AsyncIterable<Record<string, unknown>>) {
+  await clickhouse.insert({
+    table: 'trades',
+    values: Readable.from(dataSource, { objectMode: true }),
+    format: 'JSONEachRow'
+  })
+}
+```
+
+## Vistas materializadas
+
+### Agregaciones en tiempo real
+
+```sql
+-- Crear una vista materializada para estadísticas horarias
+CREATE MATERIALIZED VIEW market_stats_hourly_mv
+TO market_stats_hourly
+AS SELECT
+    toStartOfHour(timestamp) AS hour,
+    market_id,
+    sumState(amount) AS total_volume,
+    countState() AS total_trades,
+    uniqState(user_id) AS unique_users
+FROM trades
+GROUP BY hour, market_id;
+
+-- Consultar la vista materializada
+SELECT
+    hour,
+    market_id,
+    sumMerge(total_volume) AS volume,
+    countMerge(total_trades) AS trades,
+    uniqMerge(unique_users) AS users
+FROM market_stats_hourly
+WHERE hour >= now() - INTERVAL 24 HOUR
+GROUP BY hour, market_id;
+```
+
+## Monitoreo de rendimiento
+
+### Rendimiento de consultas
+
+```sql
+-- Revisar consultas lentas
+SELECT
+    query_id,
+    user,
+    query,
+    query_duration_ms,
+    read_rows,
+    read_bytes,
+    memory_usage
+FROM system.query_log
+WHERE type = 'QueryFinish'
+  AND query_duration_ms > 1000
+  AND event_time >= now() - INTERVAL 1 HOUR
+ORDER BY query_duration_ms DESC
+LIMIT 10;
+```
+
+### Estadísticas de tablas
+
+```sql
+-- Revisar tamaños de tablas
+SELECT
+    database,
+    table,
+    formatReadableSize(sum(bytes)) AS size,
+    sum(rows) AS rows,
+    max(modification_time) AS latest_modification
+FROM system.parts
+WHERE active
+GROUP BY database, table
+ORDER BY sum(bytes) DESC;
+```
+
+## Consultas analíticas comunes
+
+### Análisis de series temporales
+
+```sql
+-- Usuarios activos diarios
+SELECT
+    toDate(timestamp) AS date,
+    uniq(user_id) AS daily_active_users
+FROM events
+WHERE timestamp >= today() - INTERVAL 30 DAY
+GROUP BY date
+ORDER BY date;
+
+-- Análisis de retención
+SELECT
+    signup_date,
+    countIf(days_since_signup = 0) AS day_0,
+    countIf(days_since_signup = 1) AS day_1,
+    countIf(days_since_signup = 7) AS day_7,
+    countIf(days_since_signup = 30) AS day_30
+FROM (
+    SELECT
+        user_id,
+        min(toDate(timestamp)) AS signup_date,
+        toDate(timestamp) AS activity_date,
+        dateDiff('day', signup_date, activity_date) AS days_since_signup
+    FROM events
+    GROUP BY user_id, activity_date
+)
+GROUP BY signup_date
+ORDER BY signup_date DESC;
+```
+
+### Análisis de embudo
+
+```sql
+-- Embudo de conversión
+SELECT
+    countIf(step = 'viewed_market') AS viewed,
+    countIf(step = 'clicked_trade') AS clicked,
+    countIf(step = 'completed_trade') AS completed,
+    round(clicked / viewed * 100, 2) AS view_to_click_rate,
+    round(completed / clicked * 100, 2) AS click_to_completion_rate
+FROM (
+    SELECT
+        user_id,
+        session_id,
+        event_type AS step
+    FROM events
+    WHERE event_date = today()
+)
+GROUP BY session_id;
+```
+
+### Análisis de cohortes
+
+```sql
+-- Cohortes de usuarios por mes de registro
+SELECT
+    toStartOfMonth(signup_date) AS cohort,
+    toStartOfMonth(activity_date) AS month,
+    dateDiff('month', cohort, month) AS months_since_signup,
+    count(DISTINCT user_id) AS active_users
+FROM (
+    SELECT
+        user_id,
+        min(toDate(timestamp)) OVER (PARTITION BY user_id) AS signup_date,
+        toDate(timestamp) AS activity_date
+    FROM events
+)
+GROUP BY cohort, month, months_since_signup
+ORDER BY cohort, months_since_signup;
+```
+
+## Patrones de pipeline de datos
+
+### Patrón ETL
+
+```typescript
+// Extraer, transformar, cargar
+async function etlPipeline() {
+  // 1. Extraer de la fuente
+  const rawData = await extractFromPostgres()
+
+  // 2. Transformar
+  const transformed = rawData.map(row => ({
+    date: new Date(row.created_at).toISOString().split('T')[0],
+    market_id: row.market_slug,
+    volume: parseFloat(row.total_volume),
+    trades: parseInt(row.trade_count)
+  }))
+
+  // 3. Cargar en ClickHouse
+  await bulkInsertToClickHouse(transformed)
+}
+
+// Ejecutar periódicamente
+setInterval(etlPipeline, 60 * 60 * 1000)  // Cada hora
+```
+
+### Captura de cambios de datos (CDC)
+
+```typescript
+// Escuchar cambios en PostgreSQL y sincronizarlos a ClickHouse
+import { Client } from 'pg'
+
+const pgClient = new Client({ connectionString: process.env.DATABASE_URL })
+
+pgClient.query('LISTEN market_updates')
+
+pgClient.on('notification', async (msg) => {
+  const update = JSON.parse(msg.payload)
+
+  await clickhouse.insert({
+    table: 'market_updates',
+    values: [
+      {
+        market_id: update.id,
+        event_type: update.operation,  // INSERT, UPDATE, DELETE
+        timestamp: new Date(),
+        data: JSON.stringify(update.new_data)
+      }
+    ],
+    format: 'JSONEachRow'
+  })
+})
+```
+
+## Buenas prácticas
+
+### 1. Estrategia de particionado
+- Particiona por tiempo (normalmente mes o día).
+- Evita demasiadas particiones (impacta el rendimiento).
+- Usa el tipo DATE para la clave de partición.
+
+### 2. Clave de ordenación
+- Pon primero las columnas más filtradas.
+- Considera la cardinalidad (alta cardinalidad primero).
+- El orden impacta la compresión.
+
+### 3. Tipos de datos
+- Usa el tipo más pequeño apropiado (UInt32 vs UInt64).
+- Usa LowCardinality para strings repetidos.
+- Usa Enum para datos categóricos.
+
+### 4. Evitar
+- SELECT * (especifica las columnas).
+- FINAL (fusiona los datos antes de consultar en su lugar).
+- Demasiados JOINs (desnormaliza para analítica).
+- Inserciones pequeñas y frecuentes (agrupa por lotes).
+
+### 5. Monitoreo
+- Sigue el rendimiento de las consultas.
+- Monitorea el uso de disco.
+- Revisa las operaciones de merge.
+- Revisa el log de consultas lentas.
+
+**Recuerda**: ClickHouse sobresale en cargas analíticas. Diseña las tablas para tus patrones de consulta, agrupa las inserciones por lotes y aprovecha las vistas materializadas para agregaciones en tiempo real.