SQL e NoSQL

import { Pool } from "pg";

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

type Item = { produtoId: number; quantidade: number };

export async function criarPedido(clienteId: number, itens: Item[]) {
  const conexao = await pool.connect();
  try {
    await conexao.query("BEGIN");

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

    for (const item of itens) {
      await conexao.query(
        `INSERT INTO itens_pedido (pedido_id, produto_id, quantidade)
         VALUES ($1, $2, $3)`,
        [pedidoId, item.produtoId, item.quantidade],
      );
    }

    await conexao.query("COMMIT");
    return pedidoId;
  } catch (erro) {
    await conexao.query("ROLLBACK");
    throw erro;
  } finally {
    conexao.release();
  }
}

import psycopg


def criar_pedido(conexao: psycopg.Connection, cliente_id: int, itens: list[dict]) -> int:
    # Confirma ao sair do bloco; desfaz se houver exceção
    with conexao.transaction():
        with conexao.cursor() as cursor:
            cursor.execute(
                """INSERT INTO pedidos (cliente_id, status)
                   VALUES (%s, 'aberto') RETURNING id""",
                (cliente_id,),
            )
            pedido_id = cursor.fetchone()[0]

            cursor.executemany(
                """INSERT INTO itens_pedido (pedido_id, produto_id, quantidade)
                   VALUES (%s, %s, %s)""",
                [(pedido_id, i["produto_id"], i["quantidade"]) for i in itens],
            )
    return pedido_id

package pedidos

import (
	"context"
	"database/sql"
)

type Item struct {
	ProdutoID  int64
	Quantidade int
}

func CriarPedido(ctx context.Context, db *sql.DB, clienteID int64, itens []Item) (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

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

	for _, item := range itens {
		_, err := tx.ExecContext(ctx,
			`INSERT INTO itens_pedido (pedido_id, produto_id, quantidade)
			 VALUES ($1, $2, $3)`,
			pedidoID, item.ProdutoID, item.Quantidade,
		)
		if err != nil {
			return 0, err
		}
	}

	return pedidoID, tx.Commit()
}

import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

public class Pedidos {
    public record Item(long produtoId, int quantidade) {}

    public long criarPedido(Connection conexao, long clienteId, List<Item> itens)
            throws SQLException {
        conexao.setAutoCommit(false);
        try (var pedido = conexao.prepareStatement(
                 "INSERT INTO pedidos (cliente_id, status) VALUES (?, 'aberto') RETURNING id");
             var item = conexao.prepareStatement(
                 "INSERT INTO itens_pedido (pedido_id, produto_id, quantidade) VALUES (?, ?, ?)")) {

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

            for (Item i : itens) {
                item.setLong(1, pedidoId);
                item.setLong(2, i.produtoId());
                item.setInt(3, i.quantidade());
                item.addBatch();
            }
            item.executeBatch();

            conexao.commit();
            return pedidoId;
        } catch (SQLException erro) {
            conexao.rollback();
            throw erro;
        }
    }
}

using Npgsql;

public record Item(long ProdutoId, int Quantidade);

public class Pedidos(NpgsqlDataSource dados)
{
    public async Task<long> CriarPedido(long clienteId, IEnumerable<Item> itens)
    {
        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 pedido = new NpgsqlCommand(
            "INSERT INTO pedidos (cliente_id, status) VALUES ($1, 'aberto') RETURNING id",
            conexao, transacao)
        {
            Parameters = { new() { Value = clienteId } },
        };
        var pedidoId = (long)(await pedido.ExecuteScalarAsync())!;

        foreach (var item in itens)
        {
            await using var comando = new NpgsqlCommand(
                "INSERT INTO itens_pedido (pedido_id, produto_id, quantidade) VALUES ($1, $2, $3)",
                conexao, transacao)
            {
                Parameters =
                {
                    new() { Value = pedidoId },
                    new() { Value = item.ProdutoId },
                    new() { Value = item.Quantidade },
                },
            };
            await comando.ExecuteNonQueryAsync();
        }

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