What problems can arise from not using transactions…

The absence of transactions can lead to the following problems:

Lost Update: Two or more parallel processes attempt to update the same data. One process reads the data, the second modifies and saves it, and then the first process also modifies and saves the data, overwriting the second process's changes.

// Initial balance = 100
// Transaction 1 reads balance = 100
// Transaction 2 reads balance = 100
// Transaction 2 increases balance by 50 and saves (balance = 150)
// Transaction 1 increases balance by 20 and saves (balance = 120, although it should be 170)

Dirty Read: One process reads data that has been modified by another process but not yet committed. If the second process rolls back, the first process will work with incorrect data.

// Transaction 1 changes balance by 50 but does not commit
// Transaction 2 reads the new balance (+50)
// Transaction 1 rolls back changes
// Transaction 2 continues to work with incorrect balance

Non-repeatable Read: One process reads the same data twice within a logical operation. Between the two reads, another process modifies or deletes this data, and the first read does not match the second.
```
// Transaction 1 reads the number of goods = 10
// Transaction 2 deletes one item
// Transaction 1 reads the number of goods again = 9
```
Phantom Read: One process reads a set of data matching a certain criterion. Between two reads, another process inserts new records that match the same criterion. As a result, the second read returns more records than the first.
```
// Transaction 1 reads all orders for today (3 records)
// Transaction 2 adds a new order for today
// Transaction 1 reads all orders for today again (4 records)
```
Data Integrity Violation: When a failure occurs during the execution of a set of related operations, some operations may succeed while others fail. This leads to inconsistent data states. For example, when transferring money from one account to another, if the debit succeeds but the credit does not, money will be lost.
Scaling and Performance Issues: Without proper management of concurrent access, simultaneous operation execution can lead to locks and system slowdown. Transactions with appropriate isolation levels can help minimize these issues.

What problems can arise from not using transactions in an application?