Question

Suppose I have an order which has order lines and we have a multi-user system where different users can add order lines. Orders are persisted to the database

One business rule is that only 10 order lines can be created for an order.

What are my options to ensure that this rule is not broken? Should I check in memory and apply a lock or do I handle this in the database via procedures?

Answer 1

You have a bunch of options on how you can handle this, including: triggers, constraints, business rule logic, and data structure.

My preference is the following. Wrap all inserts/deletes/updates to orderlines in a stored procedure and only give the application layer access to the table through the stored procedure. This procedure can then enforce this and other business rules. It would also lock the table for updates while running, so only one user can change the table at any given instant.

A similar approach is to have an insert instead-of trigger on the table. This would cause the insert to fail when this (and other) business rules fail. The main concern with this is maintainability. One trigger on one table is fine. However, you can end up with a triggering nightmare if you start doing this for multiple tables with cascading inserts/deletes.

You can attempt to do this with a constraint, as one of the comments suggests. You would definitely want to test this for performance, because you have little control over how the constraint is implemented.

Also, you could have ten orderline columns in the order table. This would emphatically enforce this rule. But, there is a cost to having separate columns for each order line and having to deal with issues such as deletes.

Another option, not appropriate in this case, is to enforce the business rule at the application level. However, with multiple concurrent users, you should be doing this work in the database.