When you start a transaction, all subsequent statements that read from or write to the database occur in the context of that transaction, until the transaction is explicitly terminated or (in the case of overlapping transactions) until another transaction is started. Each statement is considered part of a group. Changes must be successfully committed to the database, or every change made in the group must be undone. 

While the transaction is in process, your view of the data in database tables is determined by your transaction isolation level. 

For TADOConnection, start a transaction by calling the BeginTrans method:

Level := ADOConnection1.BeginTrans;

Level = ADOConnection1->BeginTrans();

BeginTrans returns the level of nesting for the transaction that started. A nested transaction is one that is nested within another, parent, transaction. After the server starts the transaction, the ADO connection receives an OnBeginTransComplete event. 

For TDatabase, use the StartTransaction method instead. TDataBase does not support nested or overlapped transactions: If you call a TDatabase component's StartTransaction method while another transaction is underway, it raises an exception. To avoid calling StartTransaction, you can check the InTransaction property:

if not Database1.InTransaction then
  Database1.StartTransaction;

if (!Database1->InTransaction)
  Database1->StartTransaction();

TSQLConnection also uses the StartTransaction method, but it uses a version that gives you a lot more control. Specifically, StartTransaction takes a transaction descriptor, which lets you manage multiple simultaneous transactions and specify the transaction isolation level on a per-transaction basis. In order to manage multiple simultaneous transactions, set the TransactionID field of the transaction descriptor to a unique value. TransactionID can be any value you choose, as long as it is unique (does not conflict with any other transaction currently underway). Depending on the server, transactions started by TSQLConnection can be nested (as they can be when using ADO) or they can be overlapped.

var
  TD: TTransactionDesc;
begin
  TD.TransactionID := 1;
  TD.IsolationLevel := xilREADCOMMITTED;
  SQLConnection1.StartTransaction(TD);

TTransactionDesc TD;
TD.TransactionID = 1;
TD.IsolationLevel = xilREADCOMMITTED;
SQLConnection1->StartTransaction(TD);

By default, with overlapped transactions, the first transaction becomes inactive when the second transaction starts, although you can postpone committing or rolling back the first transaction until later. If you are using TSQLConnection with an InterBase database, you can identify each dataset in your application with a particular active transaction, by setting its TransactionLevel property. That is, after starting a second transaction, you can continue to work with both transactions simultaneously, simply by associating a dataset with the transaction you want.

if not IBDatabase1.DefaultTransaction.InTransaction then
  IBDatabase1.DefaultTransaction.StartTransaction;

if (!IBDatabase1->DefaultTransaction->InTransaction)
  IBDatabase1->DefaultTransaction->StartTransaction();

You can have overlapped transactions by using two separate transaction components. Each transaction component has a set of parameters that let you configure the transaction. These let you specify the transaction isolation level, as well as other properties of the transaction.

Ideally, a transaction should only last as long as necessary. The longer a transaction is active, the more simultaneous users that access the database, and the more concurrent, simultaneous transactions that start and end during the lifetime of your transaction, the greater the likelihood that your transaction will conflict with another when you attempt to commit any changes. 

When the actions that make up the transaction have all succeeded, you can make the database changes permanent by committing the transaction. For TDatabase, you commit a transaction using the Commitmethod:

MyOracleConnection.Commit;

MyOracleConnection->Commit();

MyOracleConnection.Commit(TD);

MyOracleConnection->Commit(TD);

IBDatabase1.DefaultTransaction.Commit;

IBDatabase1->DefaultTransaction->Commit();

ADOConnection1.CommitTrans;

ADOConnection1->CommitTrans();

MyOracleConnection.Rollback;

MyOracleConnection->Rollback();

MyOracleConnection.Rollback(TD);

MyOracleConnection->Rollback(TD);

IBDatabase1.DefaultTransaction.Rollback;

IBDatabase1->DefaultTransaction->Rollback();

ADOConnection1.RollbackTrans;

ADOConnection1->RollbackTrans();