# Transacciones bien hechas Un proceso de negocio casi nunca es una sola sentencia SQL: una salida de almacén descuenta existencia y registra el movimiento; surtir un pedido son varias salidas. Si algo falla a la mitad, la base debe quedar como estaba. Esta guía muestra un patrón probado en sistemas en producción: > **Una función por proceso.** Cada función abre una transacción **solo si no hay una abierta**, la confirma solo si la abrió ella y, si falla, la deshace solo si la abrió ella. Así la misma función sirve sola o como parte de un proceso mayor. Las funciones de transacción de `dbr` son `dbr.begin(db)`, `dbr.commit(db)`, `dbr.rollback(db)` y `dbr.in_transaction(db)` ([Transacciones en dbr](/es/devkron/2.0/bibliotecas/motor/dbr/transacciones.md)). Requisitos: la tabla `producto` de la guía [Servicio REST JSON](/es/devkron/2.0/guias/servicio-rest-json.md) y una tabla de movimientos: ```sql create table movimiento ( sys_pk int auto_increment primary key, sys_guid varchar(32), sys_dtcreated datetime, sys_timestamp datetime, sys_recver int default 0, sys_deleted tinyint default 0, sys_lock int null, sku varchar(30), cantidad decimal(14,4), referencia varchar(40) ); ``` ## 1. Los procesos `inventario.dkh` (una biblioteca: empieza con `#!` porque los archivos incluidos arrancan en contexto declarativo): ```dkl #! module "Procesos de inventario" { // Proceso simple: registra una salida y descuenta la existencia. // Se puede llamar solo o dentro de otro proceso. inv.salida::&db, sku, cantidad, referencia { propia = not(dbr.in_transaction(db)) if propia { do dbr.begin(db) } new p { @"sku": sku @"cantidad": cantidad @"referencia": referencia } existencia = dbr.num(db, "select existencia from producto where sku=@sku for update;", p) if existencia < cantidad { do rise_error(409, "Existencia insuficiente de " + sku + ": hay " + str(existencia)) } do dbr.execute(db, "update producto set existencia = existencia - @cantidad where sku=@sku;", p) do dbr.execute(db, "insert into movimiento(sys_guid,sys_dtcreated,sys_timestamp,sku,cantidad,referencia) values(replace(uuid(),'-',''),now(),now(),@sku,-@cantidad,@referencia);", p) if propia { do dbr.commit(db) } exception { if propia && dbr.in_transaction(db) { do dbr.rollback(db) } do rise_error(last_error_code(), last_error()) } } // Proceso compuesto: todas las salidas de un pedido, todo o nada. inv.surtir_pedido::&db, &partidas, referencia { propia = not(dbr.in_transaction(db)) if propia { do dbr.begin(db) } for i=0; i<@count(partidas) { ref pt = @item(partidas, i) do inv.salida(db, @@(pt,"$sku"), @@(pt,"#cantidad"), referencia) } if propia { do dbr.commit(db) } exception { if propia && dbr.in_transaction(db) { do dbr.rollback(db) } do rise_error(last_error_code(), last_error()) } } } ``` Las piezas del patrón: | Pieza | Por qué | |---|---| | `propia = not(dbr.in_transaction(db))` | Si quien llama ya abrió una transacción, esta función trabaja dentro de ella | | `if propia { do dbr.begin(db) }` | Solo abre la transacción si no había | | `if propia { do dbr.commit(db) }` | Solo confirma la que abrió: una función interna nunca confirma la transacción de su llamador | | `exception { if propia && dbr.in_transaction(db) { do dbr.rollback(db) } ... }` | Deshace solo lo suyo y **vuelve a lanzar el error** para que el llamador también deshaga | | `do rise_error(last_error_code(), last_error())` | Conserva el código (aquí 409) para quien lo necesite (un servicio puede usarlo como estado HTTP) | | `select ... for update` | Bloquea la fila del producto hasta el fin de la transacción: dos salidas simultáneas no venden la misma existencia | ## 2. Úselos ```dkl #include "dkli.dkh" #! program "transacciones" { #include "functions.dkh" #include "serialize.dkh" #include "dbr.dkh" #include "inventario.dkh" do errordet(@false) existencias::&db { return to.json(dbr.list(db, "select sku, existencia from producto where sku in ('CUA-100','LAP-HB') order by sku;", @null)) } ref db = dbr.login("principal@tienda", "web", "MiClave#2026") do dbr.execute(db, "update producto set existencia=120 where sku='CUA-100'; ", @null) do dbr.execute(db, "update producto set existencia=800 where sku='LAP-HB'; ", @null) do print("Al inicio: " + existencias(db)) // 1. Proceso simple, abre y cierra su propia transacción do inv.salida(db, "LAP-HB", 10, "VTA-1") do print("Salida sola: " + existencias(db)) // 2. Proceso compuesto que falla en la segunda partida: no se aplica nada ref pedido = from.json('[{"sku":"CUA-100","cantidad":20},{"sku":"LAP-HB","cantidad":5000}]') codeblock { do inv.surtir_pedido(db, pedido, "PED-7") exception { do print("Error: " + last_error() + " (código " + str(last_error_code()) + ")") } } do print("Tras fallo: " + existencias(db)) // 3. Proceso compuesto correcto ref pedido = from.json('[{"sku":"CUA-100","cantidad":20},{"sku":"LAP-HB","cantidad":50}]') do inv.surtir_pedido(db, pedido, "PED-8") do print("Pedido 8: " + existencias(db)) do print("¿Transacción abierta al final?: " + str(dbr.in_transaction(db))) do dbr.close(db) } ``` Salida real con MySQL 8: ```text Al inicio: [{"sku":"CUA-100","existencia":120.0000},{"sku":"LAP-HB","existencia":800.0000}] Salida sola: [{"sku":"CUA-100","existencia":120.0000},{"sku":"LAP-HB","existencia":790.0000}] Error: Existencia insuficiente de LAP-HB: hay 790.0000 (código 409) Tras fallo: [{"sku":"CUA-100","existencia":120.0000},{"sku":"LAP-HB","existencia":790.0000}] Pedido 8: [{"sku":"CUA-100","existencia":100.0000},{"sku":"LAP-HB","existencia":740.0000}] ¿Transacción abierta al final?: 0 ``` En el pedido 7, la primera partida (20 cuadernos) **sí** se había descontado dentro de la transacción, pero como la segunda falló, se deshizo todo: la existencia de `CUA-100` sigue en 120. ## 3. Cuando el llamador ya tiene una transacción Como las funciones no abren transacción si ya hay una, quien llama decide el alcance. Aquí el llamador deshace todo al final: ```dkl do dbr.begin(db) do inv.salida(db, "CUA-100", 5, "AJ-1") do print("dentro de la transacción: " + str(dbr.in_transaction(db))) do dbr.rollback(db) do print("existencia tras deshacer: " + dbr.str(db, "select existencia from producto where sku='CUA-100';", @null)) ``` ```text dentro de la transacción: 1 existencia tras deshacer: 100.0000 ``` `inv.salida` no confirmó nada, porque la transacción no era suya. ## 4. En un servicio web y en CRUD-L - En un servicio como el de [Servicio REST JSON](/es/devkron/2.0/guias/servicio-rest-json.md), llame al proceso desde el controlador; si lanza error, el `exception` del controlador responde `{success:false}`. El código (`last_error_code()`) le sirve para un estado HTTP si su API los usa. - En CRUD-L, haga lo mismo dentro de un puntero del modelo (`@create`, `@update`) y apague `@use_transaction` si su función abre la transacción ([El modelo](/es/devkron/2.0/marcos/crudl/modelo.md#transacciones-que-abarcan-más-que-el-guardado)). ## Errores típicos | Síntoma | Causa y solución | |---|---| | Se aplicó una parte del proceso | Una función interna confirmó (`commit`) la transacción de su llamador: confirme solo si `propia` | | Una transacción queda abierta tras un error (`dbr.in_transaction` sigue en 1) | Un error se atrapó con `exception` sin deshacer: deshaga y vuelva a lanzar | | Se pierde el código del error | Use `rise_error(last_error_code(), last_error())` al relanzar | | Dos ventas simultáneas dejan existencia negativa | Lea la fila con `for update` dentro de la transacción | | `Función: inv.salida no reconocida` | Las funciones deben declararse antes del código que las llama: incluya la biblioteca al principio |