Question

I was going through ACID properties regarding Transaction and encountered the statement below across the different sites
ACID is the acronym for the four properties guaranteed by transactions: atomicity, consistency, isolation, and durability.

**My question is specifically about the phrase.

guaranteed by transactions

**. As per my experience these properties are not taken care by
transaction automatically. But as a java developer we need to ensure that these properties criteria are met.

Let’s go through for each property:-

1. Atomicity:- Assume when we create the customer the account should be created too as it is compulsory. So now during transaction
   the customer gets created while during account creation some exception oocurs. So the developer can now go two ways: either he rolls back the
   complete transaction (atomicity is met in this case) or he commits the transaction so customer will be created but not the
   account (which violates the atomicity). So responsibility lies with developer?

2. Consistency:- Same reason holds valid for consistency too

3. Isolation :- as per definition isolation makes a transaction execute without interference from another process or transactions.
   But this is achieved when we set the isolation level as Serializable. Otherwis in another case like read commited or read uncommited
   changes are visible to other transactions. So responsibility lies with the developer to make it really isolated with Serializable?

4. Durability:- If we commit the transaction, then even if the application crashes, it should be committed on restart of application. Not sure if it needs to be taken care by developer or by database vendor/transaction?

So as per my understanding these ACID properties are not guaranteed automatically; rather we as a developer sjould achieve them. Please let me know
if above understanding regarding each point is correct? Would appreciate if you folks can reply for each point(yes/no will also do.

As per my understanding read committed should be most logical isolation level in most application, though it depends on requirement too.

Answer 1

The transactions guarantees ACID more or less:

1) Atomicity. Transaction guarantees all changes are made or none of them. But you need to manually set the start and end of a transaction and manually perform commit or rollback. Depending on the technology you use (EJB…), transactions are container-managed, setting the start and end to the whole “method” you are creating. You can control by configuration if a method invoked requires a new transaction or an existing one, no transaction…

2) Consistency. Guaranteed by atomicity.

3) Isolation. You must define the isolation level your application needs. Default value is defined depending upon the database, container… The commonest one is READ COMMITTED. Be careful with locks as can cause dead-lock depending on your logic and isolation level.

4) Durability. Managed entirely by the database. If your commit executes without error, nearly all database guarantees durability of changes, but some scenarios can cause to not guarantee that (writes to disk are cached in memory and flushed later…)

In general, you should be aware of transactions and configure it in the container of declare by code the star and end (commit, rollback).