Saltar al contenido

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)
  1. Qué es una condición de carrera en el inventario
  2. Solución 1: transacción con SELECT … FOR UPDATE
  3. Solución 2: UPDATE condicional con WHERE y RETURNING
  4. Cuál elegir para evitar la sobreventa
  5. Cómo probarlo con peticiones concurrentes
  6. Errores comunes
  7. Preguntas frecuentes
  8. Checklist

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;
  });
}
  1. sql.begin abre una transacción en una conexión reservada; todo lo que use tx va dentro de ella.
  2. El SELECT lee el stock, y Node decide si alcanza.
  3. 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.
  4. El UPDATE escribe el valor calculado en Node: p.stock - qty.
  5. El INSERT crea el pedido y la transacción hace COMMIT al 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.

queda 1 unidad y llegan 2 compras a la veztiempocliente Alee 1escribe 0pedido #1cliente Blee 1escribe 0pedido #2B lee antes de que A escribaresultado: 2 pedidos para 1 unidad; el stock queda en 0, no en -1cada compra decidió con un dato viejoun CHECK (stock >= 0) no lo ve: nadie escribió un número negativo

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;
  });
}
  1. El SELECT … FOR UPDATE lee y bloquea la fila del producto. Si B llega mientras A tiene el bloqueo, B espera ahí, sin leer nada.
  2. Con la fila bloqueada, la decisión en Node es segura: nadie más puede cambiar ese stock hasta el COMMIT o el ROLLBACK.
  3. 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.
  4. Al terminar la función, sql.begin hace COMMIT y libera el bloqueo. B recibe la fila con stock 0 y devuelve null: sin pedido.
SELECT … FOR UPDATE: B espera a que A terminecliente Abloquea, lee 1escribe 0COMMITfila products id = 1 bloqueadacliente BFOR UPDATEespera, sin leer nadalee 0sin pedidoen la transacción de ASELECT stock FROM products WHERE id = 1 FOR UPDATEUPDATE products SET stock = stock - 1 WHERE id = 1B recibe la fila ya actualizada: 0 unidadesel bloqueo dura hasta el COMMIT o el ROLLBACK de A

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;
  });
}
  1. El WHERE id = ${productId} AND stock >= ${qty} es la decisión. Para una unidad equivale a stock > 0; con cantidades, compara contra la cantidad pedida.
  2. RETURNING stock devuelve 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.
  3. Sin fila, p es undefined y la función devuelve null: 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

tres formas de vender la última unidadleer y escribirFOR UPDATEUPDATE … WHEREsobreventasínonosentenciasSELECT + UPDATESELECT + UPDATE1 UPDATEfila bloqueadanodesde el SELECTdesde el UPDATElógica en mediocon dato viejofila ya bloqueadano hayúsala paranadareglas que leenrestar stocklas dos soluciones dejan un solo pedidoen Read Committed, el UPDATE que esperó vuelve a evaluar su WHERE

Desliza la figura para verla completa

CriterioSELECT … FOR UPDATEUPDATE condicional
Sentencias por compraUn SELECT y un UPDATEUn UPDATE
Dónde se decideEn tu código, con la fila bloqueadaEn el WHERE
Desde cuándo está bloqueada la filaDesde el SELECT hasta el COMMITDesde el UPDATE hasta el COMMIT
Reglas que necesitan leer antesSí: límite por cliente, preventas, varias tablasSolo lo que quepa en el WHERE
Riesgo si haces algo lento dentroAlto: cada compra espera a la anteriorBajo, si no metes trabajo entre el UPDATE y el COMMIT
Úsala paraDecisiones con varias lecturasRestar 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();
}
  1. 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.
  2. Los N SELECT 1 iniciales abren todas las conexiones antes de la carrera, para que conectarse no escalone las compras.
  3. race vacía orders, fija el stock y lanza las N compras con Promise.allSettled, que espera a todas aunque alguna falle.
  4. Después cuenta los pedidos, lee el stock que quedó y los errores, y lo imprime con el tiempo total.
  5. 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.
  6. Con FOR UPDATE y con el UPDATE condicional 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 BEGIN y COMMIT bastan. 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 el WHERE.
  • Hacer trabajo lento con la fila bloqueada. Llamar a la pasarela de pagos dentro del FOR UPDATE pone en fila todas las compras del producto.
  • Usar SKIP LOCKED para 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 con stock - 1, porque un UPDATE que 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 un SELECT … 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

Luis Morales

Luis Morales

Desarrollador frontend y Shopify, EcomLabs

@luismoralesdev en Instagram

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

← Blog