Hello

Actually in the year end routines the problem arises that we have to do the complete year end routine (do everything) or in case of an error to roll back any activities (do nothing).

In this case I've a small problem.

First let us have a look onto the routine TransactionWebConnector.LoadAAnalysisAttributes. This routine does some reading and the last command is a DBAccess.GDBAccessObj.RollbackTransaction();

The rollback is a non complicated method to reset a data base connection. The other way is a DBAccess.GDBAccessObj.CommitTransaction();.

A something more correct kind of doing this would be:

try
{
  TDBTransaction transaction = DBAccess.GDBAccessObj.BeginTransaction();
  ledger = ALedgerAccess.LoadByPrimaryKey(ledgerNumber, transaction);
  DBAccess.GDBAccessObj.CommitTransaction();
  row = (ALedgerRow)ledger[0];
}
catch (Exception exception)
{
  DBAccess.GDBAccessObj.RollbackTransaction();
  throw exception;
}

If you only have to read some data you can either do:

[]Nothing[/:m]
[]CommitTransaction[/:m]
[]RollbackTransaction[/:m][/list:u]

Regardless of a little bit of unused resources everything is correct unless you do not write anything to the data base.

Furthermore, if you have to write a little bit to the data base this will not be a problem too. Whatever the last end of a read command is, it will be terminated after the next write, because in this case a commit is required.

But in periodic end operations like year and this will be difficult. The year end operation for example requires a set of reallocation accountings. Actually the routines

CloseGifts();
CloseAccounts();
CloseGLMaster();
CloseBudget();
UpdatePeriods();
SetNewYear();
Finish();

shall be filled with content and all of them writes something to the data base.

So the final construction is:

try
{
  TDBTransaction transaction = DBAccess.GDBAccessObj.BeginTransaction();
  CloseGifts(transaction);
  CloseAccounts(transaction);
  CloseGLMaster(transaction);
  CloseBudget(transaction);
  UpdatePeriods(transaction);
  SetNewYear(transaction);
  Finish(transaction);
  DBAccess.GDBAccessObj.CommitTransaction();
}
catch (DoNothingException exception)
{
  DBAccess.GDBAccessObj.RollbackTransaction();
  GenerateErrorMessage();
}

or better - we only have one transaction and can use them without a parameter list queue.

try
{
  TDBTransaction transaction = DBAccess.GDBAccessObj.BeginTransaction();
  CloseGifts();
  CloseAccounts();
  CloseGLMaster();
  CloseBudget();
  UpdatePeriods();
  SetNewYear();
  Finish();
  DBAccess.GDBAccessObj.CommitTransaction();
}
catch (DoNothingException exception)
{
  DBAccess.GDBAccessObj.RollbackTransaction();
  GenerateErrorMessage();
}

And here it is very difficult if for example a read operation in CloseBudget() always terminates with a commit or a rollback.

First idea is to split the software in a PreparationPart and in a MakeAllChangesPart in which no database readings shall be used any more. But actually there is another problem.

I've written a small Accouting tool TCommonAccountingTool which helps to organize a large number of accountings. It creates one batch data set and here a number of journals and to each journal a number of accounting transactions can be added.

Following points are important:

[]Nearly each of those operations require a "small write" (without commit!) because commonAccountingTool.AddBaseCurrencyJournal needs an intern new journal number and so on.[/:m]
[]Running a list of accountings is not the only job of a periodic end operation like year end. Other database writings shall be done before and after the accounting(s).[/:m][/list:u]

So we have to do the following:
- []We need a DBAccess.GDBAccessObj.ThrowDoNothingException-Option in the database module. If this option is set, any commit is ignored and a rollback is translated to a DoNothingException. The developer himself is responsible to catch this exception and run a rollback for the complete operation.[/:m]
  [](Optional – I’m not sure if it is really necessary if we have realized the first part. If we need it, we need it in the initialization part and if a table is not already been cached)We have to define and to use a DBAccess.GDBAccessObj.ReadOnlyTransaction() which may be closed by something like DBAccess.GDBAccessObj.CloseReadOnlyTransaction() or not. Important is: There is no need for a physical commit or rollback to the real database connection.[/:m][/list:u]
```
try
{
  DBAccess.GDBAccessObj.ThrowDoNothingException = true;
  CloseGifts();
  CloseAccounts();
  CloseGLMaster();
  CloseBudget();
  UpdatePeriods();
  SetNewYear();
  Finish();
  DBAccess.GDBAccessObj.ThrowDoNothingException = false;
  DBAccess.GDBAccessObj.CommitTransaction();
}
catch (DoNothingException exception)
{
  DBAccess.GDBAccessObj.ThrowDoNothingException = false;
  DBAccess.GDBAccessObj.RollbackTransaction();
  GenerateErrorMessage();
}
```
  Best regards
  Wolfgang