Bancos de documentos

import { MongoClient } from "mongodb";

const cliente = new MongoClient(process.env.MONGODB_URL!, { maxPoolSize: 50 });
const produtos = cliente.db("loja").collection<{ _id: number; estoque: number }>("produtos");

// A condição e a alteração vão juntas: o banco confere e grava num passo só
async function baixarEstoque(produtoId: number, quantidade: number): Promise<boolean> {
  const produto = await produtos.findOneAndUpdate(
    { _id: produtoId, estoque: { $gte: quantidade } },
    { $inc: { estoque: -quantidade } },
  );
  return produto !== null; // null: não havia estoque suficiente
}

await produtos.deleteMany({});
await produtos.insertOne({ _id: 7, estoque: 10 });
const resultados = await Promise.all(Array.from({ length: 30 }, () => baixarEstoque(7, 1)));
const final = await produtos.findOne({ _id: 7 });
console.log(`aceitas: ${resultados.filter(Boolean).length}, estoque final: ${final?.estoque}`);
await cliente.close();

import os
from concurrent.futures import ThreadPoolExecutor

from pymongo import MongoClient

cliente = MongoClient(os.environ["MONGODB_URL"], maxPoolSize=50)
produtos = cliente["loja"]["produtos"]


def baixar_estoque(produto_id: int, quantidade: int) -> bool:
    # A condição e a alteração vão juntas: o banco confere e grava num passo só
    produto = produtos.find_one_and_update(
        {"_id": produto_id, "estoque": {"$gte": quantidade}},
        {"$inc": {"estoque": -quantidade}},
    )
    return produto is not None  # None: não havia estoque suficiente


produtos.delete_many({})
produtos.insert_one({"_id": 7, "estoque": 10})
with ThreadPoolExecutor(max_workers=30) as executor:
    resultados = list(executor.map(lambda _: baixar_estoque(7, 1), range(30)))
final = produtos.find_one({"_id": 7})
print(f"aceitas: {sum(resultados)}, estoque final: {final['estoque']}")

package main

import (
	"context"
	"errors"
	"fmt"
	"os"
	"sync"
	"sync/atomic"

	"go.mongodb.org/mongo-driver/v2/bson"
	"go.mongodb.org/mongo-driver/v2/mongo"
	"go.mongodb.org/mongo-driver/v2/mongo/options"
)

// baixarEstoque confere e grava num passo só, no próprio banco
func baixarEstoque(
	ctx context.Context, produtos *mongo.Collection, id, quantidade int,
) (bool, error) {
	filtro := bson.D{
		{Key: "_id", Value: id},
		{Key: "estoque", Value: bson.D{{Key: "$gte", Value: quantidade}}},
	}
	alteracao := bson.D{{Key: "$inc", Value: bson.D{{Key: "estoque", Value: -quantidade}}}}
	err := produtos.FindOneAndUpdate(ctx, filtro, alteracao).Err()
	if errors.Is(err, mongo.ErrNoDocuments) {
		return false, nil // não havia estoque suficiente
	}
	return err == nil, err
}

func main() {
	ctx := context.Background()
	cliente, err := mongo.Connect(options.Client().ApplyURI(os.Getenv("MONGODB_URL")))
	if err != nil {
		panic(err)
	}
	defer cliente.Disconnect(ctx)
	produtos := cliente.Database("loja").Collection("produtos")

	produtos.DeleteMany(ctx, bson.D{})
	produtos.InsertOne(ctx, bson.D{{Key: "_id", Value: 7}, {Key: "estoque", Value: 10}})
	var aceitas atomic.Int64
	var wg sync.WaitGroup
	for range 30 {
		wg.Go(func() {
			if ok, _ := baixarEstoque(ctx, produtos, 7, 1); ok {
				aceitas.Add(1)
			}
		})
	}
	wg.Wait()
	var final struct{ Estoque int }
	produtos.FindOne(ctx, bson.D{{Key: "_id", Value: 7}}).Decode(&final)
	fmt.Printf("aceitas: %d, estoque final: %d\n", aceitas.Load(), final.Estoque)
}

import static com.mongodb.client.model.Filters.and;
import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Filters.gte;
import static com.mongodb.client.model.Updates.inc;

import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import java.util.ArrayList;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.bson.Document;

public class Estoque {
    // A condição e a alteração vão juntas: o banco confere e grava num passo só
    static boolean baixarEstoque(MongoCollection<Document> produtos, int id, int quantidade) {
        var produto = produtos.findOneAndUpdate(
            and(eq("_id", id), gte("estoque", quantidade)),
            inc("estoque", -quantidade));
        return produto != null; // null: não havia estoque suficiente
    }

    public static void main(String[] args) throws Exception {
        try (var cliente = MongoClients.create(System.getenv("MONGODB_URL"))) {
            var produtos = cliente.getDatabase("loja").getCollection("produtos");
            produtos.deleteMany(new Document());
            produtos.insertOne(new Document("_id", 7).append("estoque", 10));

            var resultados = new ArrayList<Future<Boolean>>();
            try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
                for (int i = 0; i < 30; i++) {
                    resultados.add(executor.submit(() -> baixarEstoque(produtos, 7, 1)));
                }
            }
            int aceitas = 0;
            for (var r : resultados) if (r.get()) aceitas++;
            var finalDoc = produtos.find(eq("_id", 7)).first();
            System.out.println("aceitas: " + aceitas
                + ", estoque final: " + finalDoc.getInteger("estoque"));
        }
    }
}

using MongoDB.Bson;
using MongoDB.Driver;

var cliente = new MongoClient(Environment.GetEnvironmentVariable("MONGODB_URL"));
var produtos = cliente.GetDatabase("loja").GetCollection<BsonDocument>("produtos");

// A condição e a alteração vão juntas: o banco confere e grava num passo só
async Task<bool> BaixarEstoque(int id, int quantidade)
{
    var filtro = Builders<BsonDocument>.Filter.Eq("_id", id)
               & Builders<BsonDocument>.Filter.Gte("estoque", quantidade);
    var alteracao = Builders<BsonDocument>.Update.Inc("estoque", -quantidade);
    var produto = await produtos.FindOneAndUpdateAsync(filtro, alteracao);
    return produto is not null; // null: não havia estoque suficiente
}

await produtos.DeleteManyAsync(FilterDefinition<BsonDocument>.Empty);
await produtos.InsertOneAsync(new BsonDocument { { "_id", 7 }, { "estoque", 10 } });
var resultados = await Task.WhenAll(Enumerable.Range(0, 30).Select(_ => BaixarEstoque(7, 1)));
var final = await produtos.Find(new BsonDocument("_id", 7)).FirstAsync();
Console.WriteLine($"aceitas: {resultados.Count(r => r)}, estoque final: {final["estoque"]}");