← Back to context

Comment by soontimes

3 hours ago

Ok, but before inserting you must ensure that inventory is not depleted, which means you need to know the count and you need to lock the row. So you still have contention on that item. Them having a 1k buffer allows not to take a lock on a single row every time, and only do it when buffer is empty

11 comments

soontimes

Reply
bijowo1676  3 hours ago

there is no need to lock the row, since you a dealing with a shopping cart, not individual item piece. when you run aggregate functions, lock is no needed, it is actually better to run it with SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED; for aggregation

the check for oversold items is extremely cheap:

  with current_order as (
    select $SKU1, $q2 as quantity
    union
    select $SKU2, $q2 as quantity
  ),
  with carts as (
    select sku, sum(quantity) as reserved
    from active_carts
    group by sku
  ),
  with warehouse as (
    select sku, available_units
    from inventory
    group by sku
  )
  select * from current_order
  inner join carts using (sku)
  inner join warehouse using (sku)
  where warehouse.available_units - carts.reserved < current_order.quantity

assuming there are indexes on sku field in both, results in efficient index seek and agg over 2 tables

  • soontimes  3 hours ago

    I don’t understand how this should prevent oversold. You have a check that reports empty or oversold inventory. But how does that check prevent 2 concurrent actors fighting for the last item from inserting 2 rows?

    • bijowo1676  3 hours ago

      how does current design resolve concurrent actors fighting for the last item ?

      there is ultimately needs to be some global mechanism resolving this conflict. Currently it is an order in which db engine processes transactions by locking rows for a transaction, whoever got the first lock, wins the last remaining items.

      my design is the same, except it does not need this dance with moving rows between tables, locking them, and the cludge with replenishment process.

      in the simplest form, run the sum() over active non-finished orders and compare to inventory. you get the same result: whoever got the first to run sum() and get positive answer will get the last remaining items.

      but the problem as formulated, imho, is not even correctly defined.

      Shopify incorrectly formulated the very problem they are trying to solve.

      Trying to solve it at the payment time is too late, its better to resolve it earlier, before the checkout.

      the "PAY" button should only do one thing: deduct money from cc and that's it. Resolving inventory availability must be solved way earlier, the moment user clicks Checkout, not when user clicks Pay.

      So ideally, the error for oversold items should be shown to a user when he clicks Checkout, not when he click PAY

      7 replies →