Cómo evitar la sobreventa de inventario en PostgreSQL
Guía/ 13 min de lectura
Dos compras de la última unidad y las dos aceptadas. Por qué leer y luego escribir vende de más, y dos arreglos en PostgreSQL: FOR UPDATE y un UPDATE condicional.
- Node.js
- Bases de datos
En este artículo (8)
La sobreventa ocurre cuando dos compras leen el mismo stock antes de que alguna lo descuente: las dos ven una unidad y las dos crean su pedido. Para evitarla en PostgreSQL, bloquea la fila con SELECT … FOR UPDATE antes de decidir, o decide y descuenta en un solo UPDATE condicional con RETURNING.
Aquí vas a ver la condición de carrera con dos compras simultáneas, las dos soluciones en SQL y en Node con el driver postgres (Postgres.js), cuál elegir y un script que lanza compras en paralelo para comprobarlo. Si además cobras en línea, el problema hermano es cobrar dos veces: lo resolvemos en cómo evitar cobros dobles con una clave de idempotencia.
Qué es una condición de carrera en el inventario
Una condición de carrera es un error que depende del orden en que se intercalan dos operaciones simultáneas. Con inventario, el caso típico es este: queda una sola sudadera (el producto 1 de estas tablas), dos clientes pagan casi al mismo tiempo y cada servidor hace lo mismo que haría si estuviera solo. Estas son las tablas de los ejemplos:
CREATE TABLE products (
id int PRIMARY KEY,
name text NOT NULL,
stock int NOT NULL CHECK (stock >= 0)
);
CREATE TABLE orders (
id serial PRIMARY KEY,
product_id int NOT NULL REFERENCES products (id),
qty int NOT NULL CHECK (qty > 0),
created_at timestamptz NOT NULL DEFAULT now()
);
INSERT INTO products (id, name, stock) VALUES (1, 'Hoodie M', 1);
Y esta es la compra escrita de la forma más natural, «lee el producto, resta uno y guarda»:
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
export async function buyNaive(sql, productId, qty, workMs = 0) {
return sql.begin(async (tx) => {
const [p] = await tx`SELECT stock FROM products WHERE id = ${productId}`;
if (!p || p.stock < qty) return null;
await sleep(workMs);
await tx`UPDATE products SET stock = ${p.stock - qty} WHERE id = ${productId}`;
const [order] = await tx`INSERT INTO orders (product_id, qty) VALUES (${productId}, ${qty}) RETURNING id`;
return order.id;
});
}
sql.beginabre una transacción en una conexión reservada; todo lo que usetxva dentro de ella.- El
SELECTlee el stock, y Node decide si alcanza. sleep(workMs)representa lo que pasa entre leer y escribir: calcular precios, envío, llamar a otro servicio. En producción ese hueco existe aunque sea de milisegundos.- El
UPDATEescribe el valor calculado en Node:p.stock - qty. - El
INSERTcrea el pedido y la transacción haceCOMMITal terminar la función.
Ahora, dos clientes a la vez. A lee 1. Antes de que A escriba, B también lee 1, porque en Read Committed, el nivel de aislamiento por defecto de PostgreSQL, cada consulta ve lo confirmado cuando empieza. Los dos calculan 1 - 1 = 0, los dos escriben 0 y los dos crean su pedido.
Desliza la figura para verla completa
Dos detalles que confunden. La transacción no lo evita: BEGIN y COMMIT agrupan las sentencias, pero no impiden que otra transacción lea la misma fila. Y un CHECK (stock >= 0) tampoco salta, porque nadie escribe un número negativo: los dos escriben 0. El stock queda bien y los pedidos quedan mal.
Solución 1: transacción con SELECT … FOR UPDATE
La primera solución es bloquear la fila al leerla. Según la documentación de bloqueo explícito, FOR UPDATE bloquea las filas leídas como si fueran a actualizarse: otras transacciones que intenten UPDATE, DELETE o SELECT … FOR UPDATE sobre ellas esperan hasta que la transacción actual termine. Y el SELECT … FOR UPDATE que esperaba, al seguir, bloquea y devuelve la fila ya actualizada.
BEGIN;
SELECT stock FROM products WHERE id = 1 FOR UPDATE;
-- tu código decide: si stock < 1, ROLLBACK
UPDATE products SET stock = stock - 1 WHERE id = 1;
INSERT INTO orders (product_id, qty) VALUES (1, 1) RETURNING id;
COMMIT;
En Node, con el mismo driver, cambia una sola cosa respecto de la versión ingenua: el FOR UPDATE y que el UPDATE resta sobre el valor de la fila, no sobre el leído.
export async function buyWithLock(sql, productId, qty, workMs = 0) {
return sql.begin(async (tx) => {
const [p] = await tx`SELECT stock FROM products WHERE id = ${productId} FOR UPDATE`;
if (!p || p.stock < qty) return null;
await sleep(workMs);
await tx`UPDATE products SET stock = stock - ${qty} WHERE id = ${productId}`;
const [order] = await tx`INSERT INTO orders (product_id, qty) VALUES (${productId}, ${qty}) RETURNING id`;
return order.id;
});
}
- El
SELECT … FOR UPDATElee y bloquea la fila del producto. Si B llega mientras A tiene el bloqueo, B espera ahí, sin leer nada. - Con la fila bloqueada, la decisión en Node es segura: nadie más puede cambiar ese stock hasta el
COMMITo elROLLBACK. stock = stock - ${qty}resta en la base de datos. Con el bloqueo daría igual usar el valor leído, pero así la sentencia es correcta por sí sola.- Al terminar la función,
sql.beginhaceCOMMITy libera el bloqueo. B recibe la fila con stock 0 y devuelvenull: sin pedido.
Desliza la figura para verla completa
El costo es que el bloqueo dura toda la transacción. Si dentro haces algo lento, cada compra del mismo producto espera a la anterior. No llames a la pasarela de pagos con la fila bloqueada. Y si una compra toca varios productos, bloquéalos siempre en el mismo orden (por ejemplo, por id): la documentación recomienda adquirir los bloqueos en un orden consistente, porque si no PostgreSQL detecta el interbloqueo y aborta una de las transacciones.
La cláusula de bloqueo de SELECT tiene dos variantes: NOWAIT da un error en lugar de esperar y SKIP LOCKED se salta las filas bloqueadas. Esta última da, según la propia documentación, una vista inconsistente de los datos: sirve para colas de trabajo, no para stock, donde haría que un producto bloqueado pareciera inexistente.
Solución 2: UPDATE condicional con WHERE y RETURNING
La segunda solución es no separar la decisión de la escritura: un solo UPDATE que resta solo si alcanza y devuelve la fila si lo hizo.
BEGIN;
UPDATE products SET stock = stock - 1
WHERE id = 1 AND stock >= 1
RETURNING stock;
-- 0 filas: no hay stock, ROLLBACK; 1 fila: crea el pedido
INSERT INTO orders (product_id, qty) VALUES (1, 1) RETURNING id;
COMMIT;
En Node:
export async function buyConditional(sql, productId, qty) {
return sql.begin(async (tx) => {
const [p] = await tx`
UPDATE products SET stock = stock - ${qty}
WHERE id = ${productId} AND stock >= ${qty}
RETURNING stock`;
if (!p) return null;
const [order] = await tx`INSERT INTO orders (product_id, qty) VALUES (${productId}, ${qty}) RETURNING id`;
return order.id;
});
}
- El
WHERE id = ${productId} AND stock >= ${qty}es la decisión. Para una unidad equivale astock > 0; con cantidades, compara contra la cantidad pedida. RETURNING stockdevuelve el stock nuevo de cada fila realmente actualizada. Según la documentación de UPDATE, si no se actualiza ninguna fila no es un error: el resultado viene vacío.- Sin fila,
pesundefinedy la función devuelvenull: no hay stock. Con fila, crea el pedido en la misma transacción.
¿Por qué funciona con dos compras a la vez? Por cómo se comporta Read Committed: si la fila ya la está actualizando otra transacción, el segundo UPDATE espera a que la primera termine. Si la primera confirma, PostgreSQL vuelve a evaluar el WHERE sobre la versión nueva de la fila. B encuentra stock = 0, la condición stock >= 1 ya no se cumple, y no actualiza nada.
Aquí también hay un bloqueo: el UPDATE bloquea la fila hasta el COMMIT. La diferencia es que empieza en el UPDATE, no en un SELECT previo, y entre medio no corre lógica de la aplicación.
Cuál elegir para evitar la sobreventa
Desliza la figura para verla completa
| Criterio | SELECT … FOR UPDATE | UPDATE condicional |
|---|---|---|
| Sentencias por compra | Un SELECT y un UPDATE | Un UPDATE |
| Dónde se decide | En tu código, con la fila bloqueada | En el WHERE |
| Desde cuándo está bloqueada la fila | Desde el SELECT hasta el COMMIT | Desde el UPDATE hasta el COMMIT |
| Reglas que necesitan leer antes | Sí: límite por cliente, preventas, varias tablas | Solo lo que quepa en el WHERE |
| Riesgo si haces algo lento dentro | Alto: cada compra espera a la anterior | Bajo, si no metes trabajo entre el UPDATE y el COMMIT |
| Úsala para | Decisiones con varias lecturas | Restar stock, el caso más común |
Nuestra recomendación: empieza por el UPDATE condicional. Es una sentencia, no depende de que el código de la aplicación sea correcto y bloquea lo mínimo. Pasa a FOR UPDATE cuando la decisión necesite leer más que el stock.
Cómo probarlo con peticiones concurrentes
Una prueba secuencial siempre pasa: una compra termina antes de que empiece la otra. Para ver la carrera hay que lanzar muchas compras a la vez, cada una en su propia conexión. Este script lanza N compras en paralelo contra el mismo producto con cada versión y comprueba el resultado con assert:
import assert from "node:assert/strict";
import postgres from "postgres";
import { buyNaive, buyWithLock, buyConditional } from "./stock.mjs";
const N = Number(process.argv[2] ?? 20);
const sql = postgres(process.env.DATABASE_URL, { max: N });
await Promise.all(Array.from({ length: N }, () => sql`SELECT 1`));
async function race(name, buy, stock) {
await sql`TRUNCATE orders RESTART IDENTITY`;
await sql`UPDATE products SET stock = ${stock} WHERE id = 1`;
const start = performance.now();
const results = await Promise.allSettled(Array.from({ length: N }, () => buy(1)));
const ms = Math.round(performance.now() - start);
const [{ orders }] = await sql`SELECT count(*)::int AS orders FROM orders`;
const [{ stock: left }] = await sql`SELECT stock FROM products WHERE id = 1`;
const failed = results.filter((r) => r.status === "rejected").length;
console.log(`${name.padEnd(16)} stock ${stock}, ${N} buyers -> ${orders} orders, stock left ${left}, ${failed} errors, ${ms} ms`);
return { orders, left, failed };
}
try {
const naive = await race("read then write", (qty) => buyNaive(sql, 1, qty, 50), 1);
assert.ok(naive.orders > 1, "the naive version should oversell");
for (const [name, buy] of [
["FOR UPDATE", (qty) => buyWithLock(sql, 1, qty, 50)],
["UPDATE ... WHERE", (qty) => buyConditional(sql, 1, qty)],
]) {
assert.deepEqual(await race(name, buy, 1), { orders: 1, left: 0, failed: 0 });
assert.deepEqual(await race(name, buy, 5), { orders: 5, left: 0, failed: 0 });
}
console.log("OK: with both solutions, never more orders than units");
} finally {
await sql.end();
}
postgres(process.env.DATABASE_URL, { max: N })abre un pool de hasta N conexiones. Postgres.js usa 10 por defecto; con menos conexiones que compras, parte de la prueba deja de ser concurrente.- Los N
SELECT 1iniciales abren todas las conexiones antes de la carrera, para que conectarse no escalone las compras. racevacíaorders, fija el stock y lanza las N compras conPromise.allSettled, que espera a todas aunque alguna falle.- Después cuenta los pedidos, lee el stock que quedó y los errores, y lo imprime con el tiempo total.
- La versión ingenua, con 50 ms entre leer y escribir, tiene que crear más de un pedido para una unidad; el script falla si no consigue mostrar la sobreventa.
- Con
FOR UPDATEy con elUPDATEcondicional exige exactamente 1 pedido con stock 1, y 5 pedidos con stock 5, sin errores.
Necesitas un PostgreSQL desechable, por ejemplo un contenedor de Docker en el puerto 55432. Nunca lo corras contra tu base de producción: el script vacía la tabla orders. Con la base lista:
export DATABASE_URL=postgres://postgres:test@localhost:55432/postgres
psql "$DATABASE_URL" -f schema.sql
node race.mjs 20
Para ver el bloqueo con tus propios ojos, abre dos sesiones de psql. En la primera ejecuta BEGIN; y el SELECT … FOR UPDATE, sin confirmar. En la segunda, el mismo SELECT … FOR UPDATE: se queda esperando. Haz COMMIT en la primera y la segunda responde al instante con la fila actualizada.
Errores comunes
- Creer que
BEGINyCOMMITbastan. En Read Committed, una transacción no impide que otra lea la misma fila antes de que la escribas. - Calcular el stock nuevo en la aplicación.
SET stock = ${valorLeido - 1}pisa lo que haya escrito otra compra. Resta en la base:stock = stock - 1, con la condición en elWHERE. - Hacer trabajo lento con la fila bloqueada. Llamar a la pasarela de pagos dentro del
FOR UPDATEpone en fila todas las compras del producto. - Usar
SKIP LOCKEDpara el stock. Se salta la fila bloqueada, así que el producto parece no existir mientras otro lo compra. - Bloquear varios productos en distinto orden. Dos carritos con los mismos productos en orden inverso pueden interbloquearse. Ordena por
id. - Fiarlo todo a un
CHECK (stock >= 0). Es una buena red cuando restas constock - 1, porque unUPDATEque lo dejaría negativo falla. Pero no ve la versión ingenua, que escribe 0 dos veces. - Probar con un pool pequeño. Con menos conexiones que compras, la prueba no es concurrente y pasa aunque el código esté mal.
Preguntas frecuentes
¿Y si subo el aislamiento a REPEATABLE READ?
La segunda transacción que intente cambiar la fila falla con could not serialize access due to concurrent update, y la documentación dice que hay que reintentar la transacción entera. Evita la sobreventa, pero te obliga a escribir reintentos. Para restar stock, el UPDATE condicional en Read Committed es más simple.
¿Cómo lo hago con varias unidades o varios productos?
Con cantidades, la condición es stock >= cantidad, como en el código de arriba. Con varios productos, un UPDATE condicional por producto dentro de la misma transacción, siempre en el mismo orden; si alguno no devuelve fila, haz ROLLBACK y nada se descuenta.
¿Qué pasa si el pago falla después de descontar el stock?
Nuestra recomendación: descuenta y crea el pedido en la misma transacción, cobra después y, si el cobro falla, devuelve la unidad con stock = stock + cantidad y marca el pedido como cancelado. Para que el cobro no se repita, usa una clave de idempotencia en el pago.
¿Funciona si uso un ORM?
Depende de lo que genere. Si tu código hace «leer el producto, restar en memoria y guardar», es la versión ingenua. Busca en tu ORM cómo emitir un UPDATE condicional o un SELECT … FOR UPDATE, o escribe en SQL directo solo este paso.
Checklist
- Ninguna compra lee el stock y lo escribe después sin bloqueo.
- El descuento es un
UPDATE … WHERE stock >= cantidad RETURNING, o va después de unSELECT … FOR UPDATE. - Una respuesta sin filas se trata como «sin stock», no como error.
- Dentro de la transacción no hay llamadas lentas a otros servicios.
- Los productos de un carrito se bloquean siempre en el mismo orden.
- La tabla tiene
CHECK (stock >= 0)como red. - Una prueba con N compras en paralelo, con al menos N conexiones, deja un solo pedido para la última unidad.
Vender lo que no tienes y cobrar dos veces son el mismo tipo de error: dos operaciones simultáneas que cada una cree estar sola. La otra mitad está en cómo evitar cobros dobles con Idempotency-Key. Si un agente de IA va a tocar tu checkout, pídele primero un plan con plan mode en Claude Code.
¿Viste esto en Instagram? Comenta STOCK en el Reel y te mando la guía.
Escrito por

Publicado el 30 de octubre de 2026 · actualizado el 1 de noviembre de 2026