theus-cli-linux-x64 1.2.2 → 1.4.0

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

@@ -1,443 +0,0 @@
----
-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.