Transações e ACID

import { Pool } from "pg";

const pool = new Pool({ connectionString: process.env.DATABASE_URL });

export class EstoqueEsgotado extends Error {}

export async function comprar(clienteId: number, produtoId: number) {
  const conexao = await pool.connect();
  try {
    await conexao.query("BEGIN");

    const baixa = await conexao.query(
      `UPDATE produtos SET estoque = estoque - 1
        WHERE id = $1 AND estoque >= 1`,
      [produtoId],
    );
    if (baixa.rowCount === 0) {
      throw new EstoqueEsgotado();
    }

    const { rows } = await conexao.query(
      `INSERT INTO pedidos (cliente_id, produto_id, status)
       VALUES ($1, $2, 'pago') RETURNING id`,
      [clienteId, produtoId],
    );

    await conexao.query("COMMIT");
    return rows[0].id;
  } catch (erro) {
    await conexao.query("ROLLBACK");
    throw erro;
  } finally {
    conexao.release();
  }
}

import psycopg


class EstoqueEsgotado(Exception):
    pass


def comprar(conexao: psycopg.Connection, cliente_id: int, produto_id: int) -> int:
    # Confirma ao sair do bloco; desfaz se houver exceção
    with conexao.transaction():
        with conexao.cursor() as cursor:
            cursor.execute(
                """UPDATE produtos SET estoque = estoque - 1
                    WHERE id = %s AND estoque >= 1""",
                (produto_id,),
            )
            if cursor.rowcount == 0:
                raise EstoqueEsgotado()

            cursor.execute(
                """INSERT INTO pedidos (cliente_id, produto_id, status)
                   VALUES (%s, %s, 'pago') RETURNING id""",
                (cliente_id, produto_id),
            )
            return cursor.fetchone()[0]

package loja

import (
	"context"
	"database/sql"
	"errors"
)

var ErrEstoqueEsgotado = errors.New("estoque esgotado")

func Comprar(ctx context.Context, db *sql.DB, clienteID, produtoID int64) (int64, error) {
	tx, err := db.BeginTx(ctx, nil)
	if err != nil {
		return 0, err
	}
	defer tx.Rollback() // não faz nada se o Commit já aconteceu

	baixa, err := tx.ExecContext(ctx,
		`UPDATE produtos SET estoque = estoque - 1
		  WHERE id = $1 AND estoque >= 1`,
		produtoID,
	)
	if err != nil {
		return 0, err
	}
	if linhas, _ := baixa.RowsAffected(); linhas == 0 {
		return 0, ErrEstoqueEsgotado
	}

	var pedidoID int64
	err = tx.QueryRowContext(ctx,
		`INSERT INTO pedidos (cliente_id, produto_id, status)
		 VALUES ($1, $2, 'pago') RETURNING id`,
		clienteID, produtoID,
	).Scan(&pedidoID)
	if err != nil {
		return 0, err
	}

	return pedidoID, tx.Commit()
}

import java.sql.Connection;
import java.sql.SQLException;

public class Loja {
    public static class EstoqueEsgotado extends Exception {}

    public long comprar(Connection conexao, long clienteId, long produtoId)
            throws SQLException, EstoqueEsgotado {
        conexao.setAutoCommit(false);
        try (var baixa = conexao.prepareStatement(
                 "UPDATE produtos SET estoque = estoque - 1 WHERE id = ? AND estoque >= 1");
             var pedido = conexao.prepareStatement(
                 "INSERT INTO pedidos (cliente_id, produto_id, status) VALUES (?, ?, 'pago') RETURNING id")) {

            baixa.setLong(1, produtoId);
            if (baixa.executeUpdate() == 0) {
                throw new EstoqueEsgotado();
            }

            pedido.setLong(1, clienteId);
            pedido.setLong(2, produtoId);
            long pedidoId;
            try (var resultado = pedido.executeQuery()) {
                resultado.next();
                pedidoId = resultado.getLong(1);
            }

            conexao.commit();
            return pedidoId;
        } catch (SQLException | EstoqueEsgotado erro) {
            conexao.rollback();
            throw erro;
        } finally {
            conexao.setAutoCommit(true);
        }
    }
}

using Npgsql;

public class EstoqueEsgotadoException : Exception;

public class Loja(NpgsqlDataSource dados)
{
    public async Task<long> Comprar(long clienteId, long produtoId)
    {
        await using var conexao = await dados.OpenConnectionAsync();
        // Sem CommitAsync, o descarte da transação desfaz tudo
        await using var transacao = await conexao.BeginTransactionAsync();

        await using var baixa = new NpgsqlCommand(
            "UPDATE produtos SET estoque = estoque - 1 WHERE id = $1 AND estoque >= 1",
            conexao, transacao)
        {
            Parameters = { new() { Value = produtoId } },
        };
        if (await baixa.ExecuteNonQueryAsync() == 0)
        {
            throw new EstoqueEsgotadoException();
        }

        await using var pedido = new NpgsqlCommand(
            "INSERT INTO pedidos (cliente_id, produto_id, status) VALUES ($1, $2, 'pago') RETURNING id",
            conexao, transacao)
        {
            Parameters =
            {
                new() { Value = clienteId },
                new() { Value = produtoId },
            },
        };
        var pedidoId = (long)(await pedido.ExecuteScalarAsync())!;

        await transacao.CommitAsync();
        return pedidoId;
    }
}