-- ===========================================================================
--  CLASE 11 · ARQUITECTURA DE SOFTWARE
--  QUIEN MANTIENE VIVO EL MODELO DE LECTURA
--
--  Esto cierra la deuda que quedo abierta al final de la clase 10:
--  construimos una tabla con la suma ya hecha... y esa tabla envejece.
--  Hay cuatro formas de mantenerla al dia. Las corremos las cuatro,
--  sobre los mismos datos, y medimos lo que cuesta cada una.
--
--  COMO SE CORRE: pegue bloque por bloque en el editor SQL. No lo corra
--  todo de una, porque la gracia esta en ver que pasa entre bloque y bloque.
-- ===========================================================================


-- ===========================================================================
--  BLOQUE 1 · LOS DOS LADOS
--  Esto es CQRS, el mismo de la clase pasada: una tabla para escribir
--  y otra para leer. Lo nuevo de hoy es QUIEN las mantiene sincronizadas.
-- ===========================================================================

-- EL LADO DE ESCRITURA. Una fila por pedido. Crece para siempre.
CREATE TABLE pedidos (
    id        int GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    categoria varchar(30)   NOT NULL,
    valor     numeric(14,2) NOT NULL
);

-- EL LADO DE LECTURA. Una fila por categoria. La suma YA HECHA.
-- Esta es la tabla que el tablero consulta. Nunca crece.
CREATE TABLE ventas_por_categoria (
    categoria varchar(30)   PRIMARY KEY,
    total     numeric(14,2) NOT NULL
);


-- ===========================================================================
--  BLOQUE 2 · MECANISMO 4 · EL TRIGGER
--  (va de cuarto en la tabla comparativa, pero lo montamos de primero
--   porque es el que abre el tema de hoy)
-- ===========================================================================

CREATE FUNCTION fn_alguien_escucha() RETURNS trigger LANGUAGE plpgsql AS $$
BEGIN
    -- Suma el valor del pedido nuevo a su categoria.
    -- ON CONFLICT: si la categoria ya existe, le suma. Si no, la crea.
    -- Lo importante: toca UNA fila. NO vuelve a leer la tabla de pedidos.
    INSERT INTO ventas_por_categoria (categoria, total)
    VALUES (NEW.categoria, NEW.valor)
    ON CONFLICT (categoria)
    DO UPDATE SET total = ventas_por_categoria.total + EXCLUDED.total;
    RETURN NEW;
END $$;

CREATE TRIGGER tg_venta_registrada
AFTER INSERT ON pedidos
FOR EACH ROW EXECUTE FUNCTION fn_alguien_escucha();


-- Tres pedidos. Lea el INSERT en voz alta antes de correrlo:
-- la palabra "ventas_por_categoria" NO aparece por ningun lado.
INSERT INTO pedidos (categoria, valor) VALUES ('Bebidas', 48000);
INSERT INTO pedidos (categoria, valor) VALUES ('Aseo',    12500);
INSERT INTO pedidos (categoria, valor) VALUES ('Bebidas', 31000);

SELECT * FROM ventas_por_categoria ORDER BY categoria;

-- ESPERADO:
--  categoria |  total
-- -----------+----------
--  Aseo      | 12500.00
--  Bebidas   | 79000.00
--
-- Guarde esos dos numeros. En hora y media van a volver a salir,
-- de un programa en Python que ni siquiera toca esta base de datos.


-- ===========================================================================
--  BLOQUE 3 · LOS OTROS TRES MECANISMOS
--  Los tres construyen el MISMO resultado, sobre los MISMOS datos.
--  Hoy los cuatro dan igual. Manana no.
-- ===========================================================================

-- MECANISMO 1 · LA VISTA
-- Una vista NO guarda nada. Es una consulta con nombre, guardada.
CREATE VIEW v_ventas AS
SELECT categoria, SUM(valor) AS total
FROM   pedidos
GROUP  BY categoria;

-- MECANISMO 2 · LA VISTA MATERIALIZADA
-- Esta SI guarda el resultado en disco. Por eso leerla es barata.
-- Y por eso mismo, se desactualiza.
CREATE MATERIALIZED VIEW mv_ventas AS
SELECT categoria, SUM(valor) AS total
FROM   pedidos
GROUP  BY categoria;

-- MECANISMO 3 · LA TABLA CONSTRUIDA DESDE UNA CONSULTA (CTAS)
-- Una fotografia. Mismo contenido, pero es una tabla normal:
-- se le pueden poner indices, permisos, y se puede actualizar por partes.
CREATE TABLE t_ventas AS
SELECT categoria, SUM(valor) AS total
FROM   pedidos
GROUP  BY categoria;


-- Los cuatro, uno al lado del otro. Hoy son identicos.
SELECT 'vista'            AS mecanismo, * FROM v_ventas
UNION ALL SELECT 'vista materializada', * FROM mv_ventas
UNION ALL SELECT 'tabla CTAS',          * FROM t_ventas
UNION ALL SELECT 'tabla + trigger',     * FROM ventas_por_categoria
ORDER BY categoria, mecanismo;


-- ===========================================================================
--  BLOQUE 4 · LLEGA UN PEDIDO NUEVO
--  Aqui es donde los cuatro dejan de ser lo mismo. Este es el bloque
--  que hay que correr despacio.
-- ===========================================================================

INSERT INTO pedidos (categoria, valor) VALUES ('Bebidas', 20000);

SELECT 'vista'            AS mecanismo, * FROM v_ventas
UNION ALL SELECT 'vista materializada', * FROM mv_ventas
UNION ALL SELECT 'tabla CTAS',          * FROM t_ventas
UNION ALL SELECT 'tabla + trigger',     * FROM ventas_por_categoria
ORDER BY categoria, mecanismo;

-- ESPERADO en Bebidas:
--   vista                 99000.00   <- al dia
--   vista materializada   79000.00   <- VIEJA
--   tabla CTAS            79000.00   <- VIEJA
--   tabla + trigger       99000.00   <- al dia
--
-- OJO CON LA PALABRA. La vista no se "actualizo": NO HABIA NADA QUE
-- ACTUALIZAR. Una vista no guarda datos. Se VOLVIO A EJECUTAR, completa,
-- contra la tabla de pedidos, en el momento en que alguien la consulto.
-- Esta siempre al dia porque siempre vuelve a leerlo todo.
--
-- La tabla del trigger tambien esta al dia, pero por el camino contrario:
-- no volvio a leer nada. Sumo 20000 a una sola fila, hace un momento,
-- cuando entro el pedido.
--
-- MISMO RESULTADO. COSTOS OPUESTOS. Eso es lo que vamos a medir.


-- Y para poner al dia a los otros dos, toca pedirselo a mano:
REFRESH MATERIALIZED VIEW mv_ventas;     -- vuelve a ejecutar la consulta COMPLETA

BEGIN;                                   -- la tabla CTAS, de la forma segura
  TRUNCATE t_ventas;
  INSERT INTO t_ventas
  SELECT categoria, SUM(valor) FROM pedidos GROUP BY categoria;
COMMIT;
-- Por que TRUNCATE + INSERT y no DROP + CREATE: DROP se lleva por delante
-- la PK, los indices y los permisos de la tabla. TRUNCATE deja todo eso
-- en pie. Y dentro de una transaccion, nadie ve la tabla vacia.


-- ===========================================================================
--  BLOQUE 5 · LO QUE CUESTA CADA UNO
--  20.000 pedidos. Esto se demora unos segundos, y la demora ES el punto.
-- ===========================================================================

-- Primero, la escritura SIN trigger. Esta es la linea base.
DROP TRIGGER tg_venta_registrada ON pedidos;

EXPLAIN (ANALYZE, COSTS OFF, BUFFERS OFF)
INSERT INTO pedidos (categoria, valor)
SELECT (ARRAY['Bebidas','Aseo','Snacks','Lacteos'])[1 + (g % 4)],
       1000 + (g % 90000)
FROM generate_series(1, 20000) g;
-- Anote el Execution Time: ______ ms


-- Ahora lo mismo, con el trigger puesto otra vez.
TRUNCATE pedidos RESTART IDENTITY;
TRUNCATE ventas_por_categoria;

CREATE TRIGGER tg_venta_registrada
AFTER INSERT ON pedidos
FOR EACH ROW EXECUTE FUNCTION fn_alguien_escucha();

EXPLAIN (ANALYZE, COSTS OFF, BUFFERS OFF)
INSERT INTO pedidos (categoria, valor)
SELECT (ARRAY['Bebidas','Aseo','Snacks','Lacteos'])[1 + (g % 4)],
       1000 + (g % 90000)
FROM generate_series(1, 20000) g;
-- Anote el Execution Time: ______ ms
--
-- Y AHORA BUSQUE ESTA LINEA EN EL PLAN, que no estaba en el anterior:
--
--     Trigger tg_venta_registrada: time=1559.776 calls=20000
--
-- PostgreSQL le esta cobrando el trigger por aparte, y le dice cuantas
-- veces corrio: una por cada fila. NO ES GRATIS, y el motor se lo factura.


-- Y ahora la lectura. Corra cada una DOS veces y tome la segunda.
EXPLAIN (ANALYZE, COSTS OFF, BUFFERS OFF) SELECT * FROM v_ventas ORDER BY categoria;
EXPLAIN (ANALYZE, COSTS OFF, BUFFERS OFF) SELECT * FROM v_ventas ORDER BY categoria;
-- Busque la linea "Seq Scan on pedidos". Mire el rows=.

EXPLAIN (ANALYZE, COSTS OFF, BUFFERS OFF) SELECT * FROM ventas_por_categoria ORDER BY categoria;
EXPLAIN (ANALYZE, COSTS OFF, BUFFERS OFF) SELECT * FROM ventas_por_categoria ORDER BY categoria;
-- Mire el rows= de esta.


-- ===========================================================================
--  LO QUE DEBERIA HABER SALIDO (medido en PostgreSQL 16, 20.000 pedidos.
--  Sus numeros van a ser distintos. Lo que importa son las proporciones.)
--
--    Escribir 20.000 pedidos SIN trigger .......    61 ms
--    Escribir 20.000 pedidos CON trigger ....... 1.614 ms   <- 26x mas caro
--        de los cuales el trigger solo ......... 1.560 ms   (calls=20000)
--
--    Leer por la vista ......................... 6,1  ms    Seq Scan rows=20000
--    Leer la tabla del trigger ................. 0,01 ms    Index Scan rows=4
--                                                           <- 500x mas barata
--
--    (La PRIMERA lectura de la tabla dio 1,5 ms y la segunda 0,01 ms:
--     la primera vez le toco traer la pagina del disco. Por eso se corre
--     dos veces y se toma la segunda. Lo mismo que hicimos la clase pasada.)
--
--  EL TRIGGER NO HACE DESAPARECER EL COSTO. LO MUEVE.
--  Lo saca de la lectura, que ocurre mil veces al dia y es la que ve el
--  usuario, y lo mete en la escritura, que ocurre una vez por pedido.
--  Ese es el negocio completo de CQRS, en dos numeros.
-- ===========================================================================


-- ===========================================================================
--  BLOQUE 6 · Y SI QUITO EL TRIGGER
-- ===========================================================================

DROP TRIGGER tg_venta_registrada ON pedidos;

INSERT INTO pedidos (categoria, valor) VALUES ('Bebidas', 99999);

SELECT * FROM ventas_por_categoria ORDER BY categoria;

-- Los totales son enormes porque venimos del bloque 5, que cargo 20.000
-- pedidos. No importa el numero: importa que es EL MISMO de antes.
-- El total de Bebidas NO SE MOVIO.
-- Nadie fallo. Nadie se quejo. No salio ningun error.
-- El tablero simplemente dejo de estar al dia, y nadie se entero.
--
-- Esa es la primera version de la frase que va a gobernar la clase de hoy:
--  >>> EL SILENCIO PARECE UN DATO. <<<


-- ===========================================================================
--  RESUMEN · LOS CUATRO MECANISMOS
--
--                         |  Al dia   | Lectura   | Que cuesta mantenerlo
--  -----------------------+-----------+-----------+------------------------
--   Vista                 |  SIEMPRE  |  CARA     | nada que mantener:
--                         |           |  lee todo | se reejecuta completa
--                         |           |           | en CADA consulta
--  -----------------------+-----------+-----------+------------------------
--   Vista materializada   |  NO       |  barata   | REFRESH a mano,
--                         |           |           | y relee TODO
--  -----------------------+-----------+-----------+------------------------
--   Tabla CTAS            |  NO       |  barata   | reconstruirla a mano,
--                         |           |  (y se le |  y relee TODO
--                         |           |  ponen    |
--                         |           |  indices) |
--  -----------------------+-----------+-----------+------------------------
--   Tabla + TRIGGER       |  SIEMPRE  |  barata   | UNA fila por pedido.
--                         |           |           | Nunca relee la tabla
--                         |           |           | de hechos
--
--  Y LA LETRA MENUDA DEL TRIGGER, QUE ES LA QUE ABRE LA CLASE DE HOY:
--
--  1. Encarece TODAS las escrituras. En esta prueba, 23 veces.
--  2. Corre DENTRO de la misma transaccion del INSERT: el que inserta
--     el pedido se queda esperando a que el trigger termine.
--  3. Solo funciona dentro de la misma base de datos. Si el que necesita
--     enterarse esta en otro sistema, el trigger no llega hasta alla.
--
--  El punto 1 y el 3 son el precio. El punto 2 es la puerta:
--  el trigger rompe el acoplamiento DE CODIGO (el INSERT no nombra a nadie)
--  pero NO rompe el acoplamiento DE TIEMPO (el que inserta espera).
--  Una arquitectura por eventos rompe los dos.
--
--  Eso es lo que vamos a construir en los proximos 70 minutos.
-- ===========================================================================
