Transactions

There are two major aspects to transaction processing, atomicity and automatic recovery. These are related yet different aspects of transaction processing, and not all products supply both. FairCom DB API provides a set of functions and file modes that cover both aspects of transaction processing.

Atomicity

Often, when updating a table, you perform several functions in a group. For instance, when creating an invoice, you update several tables: the account balance in the customer file, the invoice file, an invoice detail file, inventory records, and others. It is important that all of these actions take place to keep the files synchronized. If some of the actions take place, but not all, your files may be out of sync, and it can be difficult to correct the problem later. If one action cannot take place, it would be best to not let any take place. We call this atomicity. The FairCom DB API API provides functions that provide this feature. You can mark a set of operations so that none will take place unless they can all take place. The API goes beyond this, allowing you to create "savepoints" where you can partially back out a group of operations, and "roll back" transactions to a given point, so that you can restore your data back to a state that it was in sometime in the past.

Automatic Recovery

Once you establish full transaction processing by creating tables using the CTCREATE_TRNLOG mode, you can take advantage of the automatic recovery feature. Atomicity will generally prevent problems of files being partially updated. However, there are still situations where a system crash can cause data to be lost. Once you have signaled the end of a transaction, there is still a "window of vulnerability" while the application is actually committing the transaction updates to disk. In addition, for speed considerations some systems buffer the data files and indexes, so that updates may not be flushed to disk immediately. If the system crashes, and one of these problems exists, the recovery logic detects it. If you set up the system for automatic file recovery, the recovery logic automatically resets the table back to the last, most complete, state that it can. If any transaction sets have not been completed, or "committed", they will not affect the table.

Error During Automatic Recovery

An error 14, FCRP_ERR, indicates that FairCom Server detected that files appear corrupt at open. This occurs if files have been updated but not properly closed. They were not processed by automatic recovery so they are in an unknown (inconsistent) state.

If your transaction logs are corrupted, preventing automatic recovery from occurring, you can either:

• Restore from a backup and reapply changes if available (e.g., from application log or forward roll of good transaction logs you have saved).

or

• Rebuild the files, which will clear the error 14 but will still leave the files in a possibly inconsistent state. In this situation the files will not be guaranteed to be consistent as of any point in time; they can contain a mixture of old/new data, and the data files may not match the index files, due to caching.

Creating tables for transaction processing

Only tables created with the create modes CTCREATE_PREIMG and CTCREATE_TRNLOG will participate in a transaction. This means that the ctdbBegin(), ctdbCommit(), and ctdbAbort() functions provide transaction atomicity when used with records from these two types of tables. This also means that these three functions do NOT provide atomicity when used with records from other types of tables, such as CTCREATE_NORMAL tables. Record operations (and locks) on NORMAL tables are handled as if there was no transaction running. For CTCREATE_PREIMG and CTCREATE_TRNLOG tables to provide the promised protections, all operations that add, modify, and delete records in these tables must be done inside a transaction (between calls to ctdbBegin() and ctdbCommit() / ctdbAbort()). This is enforced by FairCom DB API; attempting to modify records outside of a transaction for these tables will generate an error.

Tables created with CTCREATE_PREIMG mode will participate in a transaction, and will benefit from transaction atomicity, but will not have automatic recovery, because the transaction log files needed for automatic recovery will not be generated. This saves disk space and gives speed gains, at the cost of more difficult recovery in case of a crash.

Tables created with CTCREATE_TRNLOG have all the positive attributes of CTCREATE_PREIMG but will also generate the transaction logs necessary for automatic recovery.

Starting a transaction

Using our example from above, you don’t want to have the transaction group involve more than one invoice. You also don’t want it to involve less than a whole invoice.

Record locks are held on updated records for the duration of the transaction, so you don’t want to make the transaction group too large or it will consume the system resources and cause delays. On the other hand, you may not want to make the transaction group too small or the effect of grouping actions is lost.

The Begin method of classes CTSession(), CTDatabase(), CTTable() and CTRecord() starts a new transaction. Choose logical groups of file updates to be delimited as transactions.

// start a new transaction
try
{
   ARecord.Begin()
}
catch (CTException &err)
{
   printf("Begin transaction failed with error %d\n", err.GetErrorCode());
}

Terminating a transaction

When all update operations have been completed, terminate a transaction by calling the Commit method to commit all changes.

// Start transaction
ARecord.Begin();
// write the record
try
{
   ARecord.Write();
   ARecord.Commit();
}
catch (CTException &err)
{
   ARecord.Abort();
   printf("Commit transaction failed with error %d\n", err.GetErrorCode());
}

Call Abort() to terminate the transaction and abort all changes since the start of the transaction.

Save Points

There are times when you want to abort only a portion of a transaction. You may be processing several optional paths of a program, going down one branch, then backing out and trying another branch. It may be possible that you don’t want any of the updates to occur until you are completely finished, but you want the flexibility to back out part of the updates. Another possibility would be if you have run into some form of update error, such as an add record failing due to a duplicate key. You would want to back up to a prior point, correct the problem, and continue. The c-tree Servers let you implement this by using savepoints.

A savepoint is a temporary spot in the transaction that you may want to rollback to without having to abort the entire transaction. During a transaction, when you want to put a placeholder in the process, call the SetSavePoint() method. This does not commit any of the updates. The function returns a savepoint number, which you should keep track of. You can make as many SavePoint calls as you wish during a transaction, and each time you will be given a unique savepoint number.

When you decide that you want to rollback to a savepoint previously saved by a call to SetSavePoint(), issue a RestoreSavePoint() call. You should pass to RestoreSavePoint() the savepoint number that you saved.. This returns your data to the state it was at the point you issued the specified SetSavePoint() call, without aborting the entire transaction.

Locking

The most significant difference between coding applications for single-user environments and multi-user environments (including local area networks) has to do with performing record updates (rewrites) and record deletions.

The basic problem is that to perform a record update or deletion in a multi-user system, you must own a record lock on the record of interest. Locks should be acquired when the user reads the record in preparation for updates, and the programmer should not relinquish the lock until the update is completed. However, one must be careful to ensure that locks are held for the shortest time possible or the performance of the application will be adversely affected.

Two types of locks can be applied to a record:

• A READ lock (also called a "shared" lock) on a record allows an unlimited number of other READ locks on that record (from other threads, etc), but prevents WRITE locks.
• A WRITE lock (also called an "exclusive" lock) prevents any other locks (of either type) on that record.

The FairCom DB API API provides two methods of acquiring these record locks – session-wide record locking (discussed in Starting Session-Wide Locking below) and manual record locking (discussed in the Working with Records / Record Locking section). Session-wide locking is the preferred method, because it is safer:

• With session-wide record locking, you turn on automatic locking, and then any subsequent record reads, writes, or deletions will be automatically locked with the specified lock type.
• With manual record locking, you read a record and then lock it "by hand", by calling a "Lock Record" function, which leaves a window of opportunity for another thread to modify or delete the record after you read it and before you lock it. That is why session-wide locking is the preferred method of acquiring record locks.

Starting locks

Start acquiring locks by passing the appropriate lock mode to the Lock method inherited by CTSession(), CTDatabase(), CTTable(), and CTRecord() from CTBase().

// start locking
ARecord.Lock(CTLOCK_WRITE_BLOCK);
After a successful call to Lock, the FairCom DB API API locks all records as they are read using the lock mode passed to Lock. Suspend record locking temporarily by calling the Lock function with the mode CTLOCK_SUSPEND. Suspending locks does not release any locks, but while locks are suspended, no record reads are automatically locked.
// suspend locking
ARecord.Lock(CTLOCK_SUSPEND);
Suspended locking can be resumed by calling Lock with a resume lock mode: CTLOCK_RESUME_READ, CTLOCK_RESUME_LOCK_BLOCK, CTLOCK_RESUME_WRITE, or CTLOCK_RESUME_WRITE_BLOCK.
// resume locking
try
{
   ARecord.Lock(CTLOCK_RESUME_WRITE_BLOCK);
}
catch (CTException &err)
{
   printf("Resume lock failed with error %d\n", err.GetErrorCode());
}

Lock modes

Use the following lock modes when calling Lock():

FairCom DB API .NET Lock Modes are defined in the LOCK_MODE enum.

Freeing locks

Locks are freed by calling Unlock() or by calling Lock() with the CTLOCK_FREE mode. If freeing locks inside an active transaction, the locks of updated records will only be actually freed when the transaction terminates.

// free locks
ARecord.Unlock();

Freeing locks associated with a table

You can free only the locks associated with a table by calling the CTTable::UnlockTable() method. Only the locks held for records of the table are released, and all other record locks are kept.

// free locks for a table
try
{
ATable.UnlockTable();
}
catch (CTException &err)
{
   printf("Unlock table failed with error %d\n", err.GetErrorCode());
}

If freeing locks associated with a table inside an active transaction, the locks of updated records will only be actually freed when the transaction terminates.