Fundamentos de Datos

Key-Value Stores — Redis, DynamoDB, Memcached

La forma más simple de NoSQL. Cada dato se identifica por una clave única y su valor puede ser cualquier estructura.

# Redis - Operaciones básicas
# String
SET user:1:session "abc123" EX 3600  # TTL de 1 hora

# Hash (objeto)
HSET user:1 name "Ana" email "ana@example.com"
HGET user:1 name

# List (cola FIFO)
LPUSH notifications:1 "New order received"
RPOP notifications:1

# Sorted Set (leaderboard)
ZADD leaderboard 1500 "player:1"
ZADD leaderboard 2300 "player:2"
ZREVRANGE leaderboard 0 9 WITHSCORES  # Top 10

# Pub/Sub
PUBLISH channel:orders "new_order:ORD-005"

Casos de uso: Caché, sesiones, leaderboards, colas de mensajes, rate limiting.

Fortalezas: Latencia sub-milisegundo, extremadamente simple, muy alta throughput.

Column-Family Stores — Cassandra, HBase, Bigtable

Organizan datos en familias de columnas. Optimizados para escrituras masivas y consultas por rango de tiempo.

-- Cassandra CQL (Cassandra Query Language)
-- Diseñado para escrituras/lecturas masivas
CREATE TABLE sensor_readings (
    device_id   UUID,
    timestamp   TIMESTAMP,
    temperature DOUBLE,
    humidity    DOUBLE,
    pressure    DOUBLE,
    PRIMARY KEY (device_id, timestamp)  
    -- Partition key: device_id
    -- Clustering key: timestamp (orden cronológico)
) WITH CLUSTERING ORDER BY (timestamp DESC)
  AND compaction = {'class': 'TimeWindowCompactionStrategy'};

-- Insert masivo (diseñado para esto)
INSERT INTO sensor_readings 
  (device_id, timestamp, temperature, humidity)
VALUES (uuid(), toTimestamp(now()), 22.5, 65.0);

-- Query eficiente (usa partition key)
SELECT * FROM sensor_readings 
WHERE device_id = 550e8400-e29b-41d4-a716-446655440000
  AND timestamp > '2026-01-01'
LIMIT 1000;

Casos de uso: IoT data, series de tiempo, logs a escala masiva, datos de sensores.

Fortalezas: Escalabilidad lineal, alta disponibilidad, writes de alta throughput, distribución geográfica.

Graph Databases — Neo4j, Amazon Neptune, TigerGraph

Modelan datos como nodos y relaciones (aristas). Excelentes para datos altamente relacionados donde los JOINs serían prohibitivos.

// Neo4j - Cypher Query Language
// Crear nodos y relaciones
CREATE (ana:Person {name: 'Ana', age: 28})
CREATE (carlos:Person {name: 'Carlos', age: 32})
CREATE (python:Skill {name: 'Python', level: 'Advanced'})
CREATE (spark:Skill {name: 'Apache Spark', level: 'Intermediate'})

CREATE (ana)-[:KNOWS]->(carlos)
CREATE (ana)-[:HAS_SKILL]->(python)
CREATE (ana)-[:HAS_SKILL]->(spark)
CREATE (carlos)-[:HAS_SKILL]->(spark)

// Consultar: amigos con skill en Spark
MATCH (p:Person)-[:KNOWS]-(friend)-[:HAS_SKILL]->(s:Skill)
WHERE p.name = 'Ana' AND s.name = 'Apache Spark'
RETURN friend.name, s.level

Casos de uso: Redes sociales, detección de fraude, sistemas de recomendación, conocimiento empresarial, grafos de conocimiento.

Fortalezas: Traversal de relaciones complejo en tiempo constante, consultas de grafos naturales.

Time Series Databases — InfluxDB, TimescaleDB, Prometheus

Optimizadas específicamente para datos secuenciales en el tiempo. Comprensión nativa del concepto de "timestamp".

-- TimescaleDB (extensión de PostgreSQL)
-- Crear hypertable (tabla optimizada para time series)
CREATE TABLE cpu_metrics (
    time        TIMESTAMPTZ NOT NULL,
    host        TEXT NOT NULL,
    cpu_usage   DOUBLE PRECISION,
    memory_usage DOUBLE PRECISION
);

SELECT create_hypertable('cpu_metrics', 'time');

-- Insert data
INSERT INTO cpu_metrics VALUES
(NOW(), 'server-01', 45.2, 72.1),
(NOW(), 'server-02', 23.1, 55.3);

-- Time-series query con bucketing
SELECT 
    time_bucket('5 minutes', time) AS bucket,
    host,
    AVG(cpu_usage) as avg_cpu,
    MAX(cpu_usage) as max_cpu
FROM cpu_metrics
WHERE time > NOW() - INTERVAL '1 hour'
GROUP BY bucket, host
ORDER BY bucket DESC;

Casos de uso: Monitoring de infraestructura, métricas de aplicaciones, datos financieros (OHLCV), IoT, observabilidad.

Data Lake

Un Data Lake es un repositorio que almacena datos en su formato nativo (crudo) hasta que sean necesarios. El principio es: "Store everything, figure out schema later".

• Estructura: Schema-on-read. El esquema se aplica al leer, no al escribir.
• Formato: Todo: JSON, CSV, Parquet, Avro, imágenes, videos, logs, audio.
• Costo: Muy barato por GB (object storage: S3, GCS, ADLS).
• Escalabilidad: Prácticamente ilimitada. Exabytes posibles.
• Problema histórico: Fácil que se convierta en un "Data Swamp" (sin governance).
• Ejemplos: S3 + Hadoop, GCS + Dataproc, ADLS + Azure HDInsight.
• Casos de uso: ML training data, raw event storage, archivado, datos no estructurados.

Lakehouse (El Estándar 2026)

El Lakehouse combina la flexibilidad y el bajo costo del Data Lake con las capacidades analíticas y ACID del Data Warehouse. Permite SQL directo sobre object storage.

• Tecnologías clave: Delta Lake (Databricks), Apache Iceberg, Apache Hudi
• ACID sobre object storage: Transacciones confiables sobre S3/GCS/ADLS
• Time Travel: Consultar versiones históricas de los datos
• Schema Evolution: Cambiar esquemas sin reescribir todos los datos
• Unified batch + streaming: El mismo sistema para ambos paradigmas
• Open formats: Parquet + metadata layer, sin vendor lock-in
• Casos de uso: El estándar para arquitecturas modernas que necesitan tanto ML como BI

# Delta Lake con PySpark
from pyspark.sql import SparkSession
from delta import configure_spark_with_delta_pip

spark = (configure_spark_with_delta_pip(
    SparkSession.builder
    .appName("lakehouse_demo")
    .config("spark.sql.extensions", "io.delta.sql.DeltaSparkSessionExtension")
).getOrCreate())

# Escribir como Delta Table
df.write.format("delta").mode("overwrite").save("gs://my-lake/silver/orders/")

# ACID MERGE (upsert)
from delta.tables import DeltaTable
delta_table = DeltaTable.forPath(spark, "gs://my-lake/silver/orders/")
delta_table.alias("target").merge(
    updates_df.alias("source"),
    "target.order_id = source.order_id"
).whenMatchedUpdateAll() \
 .whenNotMatchedInsertAll() \
 .execute()

# Time Travel - consultar versión anterior
df_yesterday = spark.read.format("delta") \
    .option("versionAsOf", 5) \
    .load("gs://my-lake/silver/orders/")