La carga de las tres de la mañana

En el capítulo 15 armamos el almacén de una vez. Ahora la parte que se repite: mañana llegan los pedidos de hoy, y pasado los de mañana.

Las dos formas de hacerlo son borrar todo y volver a cargar, o traer solo lo nuevo. La primera es más simple y aguanta bastante más de lo que la gente cree; la segunda es la que hace falta cuando la tabla ya no cabe en la ventana de la madrugada.

Preparo la base con una columna que casi ninguna tabla de sistema trae de fábrica y que es el centro del capítulo:

ALTER TABLE pedidos ADD COLUMN cargado_en TEXT;
UPDATE pedidos SET cargado_en = fecha;

SELECT count(*) AS pedidos, min(fecha) AS desde, max(fecha) AS hasta FROM pedidos;

pedidos  desde       hasta
-------  ----------  ----------
900      2025-01-01  2026-06-24

Novecientos pedidos, año y medio. De momento cargado_en es igual a fecha, o sea que hago como si cada pedido hubiera entrado el mismo día que se hizo. Dentro de un rato dejará de ser verdad, y ahí está el capítulo entero 🙂

La marca de agua

La idea es de una línea: guarda hasta dónde cargaste, y la próxima vez trae lo que venga después. Eso que guardas se llama marca de agua, o watermark si estás leyendo documentación.

Lo bonito es que no hace falta guardarla en ningún sitio: se le pregunta a la tabla de destino.

CREATE TABLE ventas_dw (
    id_pedido  INTEGER PRIMARY KEY,
    fecha      TEXT NOT NULL,
    canal      TEXT,
    monto      REAL,
    cargado_en TEXT
);

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos
WHERE cargado_en > (SELECT max(cargado_en) FROM ventas_dw);

SELECT count(*) AS filas_cargadas FROM ventas_dw;

filas_cargadas
--------------
0

Cero 😐

Y no falló nada. La tabla estaba vacía, max(cargado_en) sobre una tabla vacía devuelve NULL, y cualquier comparación contra NULL da NULL, que no es verdadero. El WHERE no dejó pasar ni una fila.

Es la lección de los nulos del capítulo 4 llegando a la peor hora posible: la primera carga de la historia, la que nadie mira porque "acaba de empezar". Se arregla con un coalesce:

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos
WHERE cargado_en > coalesce((SELECT max(cargado_en) FROM ventas_dw), '0000-00-00')
  AND cargado_en < '2026-06-20';

SELECT count(*) AS filas, max(cargado_en) AS marca FROM ventas_dw;

filas  marca
-----  ----------
890    2026-06-19

890 filas y la marca en el 19 de junio. El AND del final está para simular que hoy es 20 de junio y quedan cuatro días por cargar.

Correrla otra vez, que es lo que va a pasar

Ahora la carga de la noche siguiente. Y voy a escribirla con el error que se escribe siempre, que es usar >= en vez de > "por si acaso":

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos
WHERE cargado_en >= (SELECT max(cargado_en) FROM ventas_dw);

IntegrityError: UNIQUE constraint failed: ventas_dw.id_pedido

El >= vuelve a traer el día que ya estaba cargado, y la clave primaria lo caza. Y acá hay que decir algo importante: que reviente es la buena noticia.

Sin esa clave primaria, esas filas habrían entrado dos veces, la carga habría terminado en verde, y la venta del 19 de junio saldría duplicada en el reporte del lunes sin que nadie lo note. La restricción del capítulo 11 está haciendo exactamente su trabajo 💛

Que se pueda correr dos veces: idempotencia

La palabra suena a examen y la idea es simple: correr la carga dos veces tiene que dejar la tabla igual que correrla una.

Hace falta porque las cargas se repiten todo el tiempo. Se cayó a mitad y la relanzas. Alguien la lanzó a mano sin saber que ya había corrido. El servidor se reinició y el planificador la disparó otra vez. Si repetir duplica, cualquiera de esas tres te ensucia el almacén.

La forma es el upsert del capítulo 12:

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos
WHERE cargado_en >= (SELECT max(cargado_en) FROM ventas_dw)
ON CONFLICT (id_pedido) DO UPDATE
SET fecha = excluded.fecha, canal = excluded.canal, monto = excluded.monto,
    cargado_en = excluded.cargado_en;

SELECT count(*) AS filas, max(cargado_en) AS marca,
       round(sum(monto), 2) AS venta FROM ventas_dw;

filas  marca       venta
-----  ----------  ---------
900    2026-06-24  532653.85

Las 900. Y ahora la prueba, que es correr lo mismo otra vez:

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos
WHERE cargado_en >= (SELECT max(cargado_en) FROM ventas_dw)
ON CONFLICT (id_pedido) DO UPDATE
SET fecha = excluded.fecha, canal = excluded.canal, monto = excluded.monto,
    cargado_en = excluded.cargado_en;

SELECT count(*) AS filas, round(sum(monto), 2) AS venta FROM ventas_dw;

filas  venta
-----  ---------
900    532653.85

Mismo número de filas y misma venta. Eso es idempotente, y es lo que te deja dormir cuando la carga falla a las tres de la mañana: relanzas y ya 🌙

Los dos relojes

Acá viene lo que más datos pierde en el mundo real, y es tan silencioso como el JOIN del capítulo anterior.

Entra un pedido con fecha del 10 de junio, que se cargó hoy 25 porque el marketplace lo mandó tarde:

INSERT INTO pedidos (id, id_cliente, fecha, canal, monto, cargado_en)
VALUES (99001, 7, '2026-06-10', 'WhatsApp', 480.5, '2026-06-25');

SELECT (SELECT count(*) FROM pedidos)   AS en_el_origen,
       (SELECT count(*) FROM ventas_dw) AS en_el_almacen,
       (SELECT max(fecha) FROM ventas_dw) AS marca_por_fecha,
       (SELECT max(cargado_en) FROM ventas_dw) AS marca_por_carga;

en_el_origen  en_el_almacen  marca_por_fecha  marca_por_carga
------------  -------------  ---------------  ---------------
901           900            2026-06-24       2026-06-24

901 en el origen, 900 en el almacén. Corre la carga usando la fecha del pedido, que es lo que hace casi todo el mundo:

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos
WHERE fecha >= (SELECT max(fecha) FROM ventas_dw)
ON CONFLICT (id_pedido) DO UPDATE
SET fecha = excluded.fecha, monto = excluded.monto, cargado_en = excluded.cargado_en;

SELECT count(*) AS en_el_almacen FROM ventas_dw;

en_el_almacen
-------------
900

Sigue en 900. La venta de 480,50 soles existe, entró bien, está en el origen, y tu almacén no la va a ver nunca, porque su fecha es más vieja que la marca de agua y ese pedido ya pasó de largo.

La cura es cambiar de reloj:

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos
WHERE cargado_en >= (SELECT max(cargado_en) FROM ventas_dw)
ON CONFLICT (id_pedido) DO UPDATE
SET fecha = excluded.fecha, monto = excluded.monto, cargado_en = excluded.cargado_en;

SELECT (SELECT count(*) FROM pedidos)   AS en_el_origen,
       (SELECT count(*) FROM ventas_dw) AS en_el_almacen;

en_el_origen  en_el_almacen
------------  -------------
901           901

Los dos relojes tienen nombre y conviene sabérselos porque salen en toda la documentación: la fecha del pedido es hora del negocio, y la de carga es hora de ingesta. Se reportan por la primera y se carga por la segunda 📏

Y si el sistema de origen no guarda la hora de ingesta, esa es una petición de las que se piden el día uno, como en cualquier proyecto de datos.

La bitácora, que contesta "¿corrió?"

Una tabla más, y es la que te salva de la peor pregunta de un lunes, que es "¿esto está actualizado?":

CREATE TABLE carga_log (
    id         INTEGER PRIMARY KEY,
    tabla      TEXT,
    corrio_en  TEXT,
    desde      TEXT,
    filas      INTEGER,
    estado     TEXT
);

INSERT INTO carga_log (tabla, corrio_en, desde, filas, estado) VALUES
    ('ventas_dw', '2026-06-20 03:00', '2026-06-19', 10, 'ok'),
    ('ventas_dw', '2026-06-25 03:00', '2026-06-24',  1, 'ok'),
    ('ventas_dw', '2026-06-26 03:00', '2026-06-25',  0, 'sin datos');

SELECT corrio_en, desde, filas, estado FROM carga_log ORDER BY corrio_en;

corrio_en         desde       filas  estado
----------------  ----------  -----  ---------
2026-06-20 03:00  2026-06-19  10     ok
2026-06-25 03:00  2026-06-24  1      ok
2026-06-26 03:00  2026-06-25  0      sin datos

Mira la última fila. Cero filas no es un error: puede ser un domingo sin ventas o puede ser que el origen dejó de mandar. Las dos se ven igual, y por eso se anota en vez de discutirse de memoria.

Ejercicios

DELETE FROM ventas_dw WHERE cargado_en >= '2026-06-18';

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos
WHERE cargado_en >= '2026-06-18';

SELECT count(*) AS filas, round(sum(monto), 2) AS venta FROM ventas_dw;

filas  venta
-----  ---------
901    533134.35

UPDATE pedidos SET monto = monto + 100 WHERE id = 99001;

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos WHERE id = 99001
ON CONFLICT (id_pedido) DO UPDATE SET monto = excluded.monto;

SELECT id_pedido, monto FROM ventas_dw WHERE id_pedido = 99001;

id_pedido  monto
---------  -----
99001      580.5

DELETE FROM pedidos WHERE id = 99001;

SELECT (SELECT count(*) FROM pedidos)   AS en_el_origen,
       (SELECT count(*) FROM ventas_dw) AS en_el_almacen,
       (SELECT count(*) FROM ventas_dw v
        WHERE NOT EXISTS (SELECT 1 FROM pedidos p WHERE p.id = v.id_pedido)) AS fantasmas;

en_el_origen  en_el_almacen  fantasmas
------------  -------------  ---------
900           901            1

SELECT corrio_en, filas, estado FROM carga_log
WHERE filas = 0 OR estado <> 'ok';

corrio_en         filas  estado
----------------  -----  ---------
2026-06-26 03:00  0      sin datos

INSERT INTO pedidos (id, id_cliente, fecha, canal, monto, cargado_en)
VALUES (99002, 7, '2099-01-01', 'Web', 12.0, '2099-01-01');

INSERT INTO ventas_dw (id_pedido, fecha, canal, monto, cargado_en)
SELECT id, fecha, canal, monto, cargado_en FROM pedidos
WHERE cargado_en > (SELECT max(cargado_en) FROM ventas_dw)
ON CONFLICT (id_pedido) DO UPDATE SET monto = excluded.monto;

SELECT max(cargado_en) AS marca_de_agua,
       (SELECT count(*) FROM pedidos
        WHERE cargado_en > (SELECT max(cargado_en) FROM ventas_dw)) AS lo_que_traeria_manana
FROM ventas_dw;

marca_de_agua  lo_que_traeria_manana
-------------  ---------------------
2099-01-01     0

Preguntas frecuentes