The system implementation of a transaction model that handles isolated operations within a database context. More...

Inheritance diagram for Deveel.Data.Transactions.Transaction:

Classes
class	OldAndNewTableContainer

class	TransactionTableContainer

Public Member Functions
void	SetTableState (OldNewTableState tableState)

void	Commit ()
	Commits all write operation done during the lifetime of this transaction and invalidates it. More...

void	RegisterOnCommit (Action< TableCommitInfo > action)

void	UnregisterOnCommit (Action< TableCommitInfo > action)

void	Rollback ()
	Rollback any write operations done during the lifetime of this transaction and invalidates it. More...

void	Dispose ()

Package Functions
	Transaction (ITransactionContext context, Database database, int commitId, IsolationLevel isolation, IEnumerable< TableSource > committedTables, IEnumerable< IIndexSet > indexSets)

	Transaction (ITransactionContext context, Database database, int commitId, IsolationLevel isolation)

Properties
int	CommitId `[get, private set]`

IsolationLevel	Isolation `[get, private set]`

bool	IsClosed `[get, set]`

OldNewTableState	TableState `[get, private set]`

ITransactionContext	Context `[get, private set]`

IDatabase ITransaction.	Database `[get]`

Database	Database `[get, private set]`

IEventSource IEventSource.	ParentSource `[get]`

IEnumerable< KeyValuePair< string, object > > IEventSource.	Metadata `[get]`

IContext IEventSource.	Context `[get]`

IDatabaseContext	DatabaseContext `[get]`

TableSourceComposite	TableComposite `[get]`

SequenceManager	SequenceManager `[get]`

ViewManager	ViewManager `[get]`

TriggerManager	TriggerManager `[get]`

TransactionRegistry	Registry `[get, private set]`

TableManager	TableManager `[get]`

Properties inherited from Deveel.Data.Transactions.ITransaction
new ITransactionContext	Context `[get]`

int	CommitId `[get]`
	Gets a number uniquely identifying a transaction within a database context. More...

IsolationLevel	Isolation `[get]`
	Gets the isolation level of the transaction. More...

IDatabase	Database `[get]`
	Gets the database this transaction belongs to. More...

TransactionRegistry	Registry `[get]`

Properties inherited from Deveel.Data.Diagnostics.IEventSource
IContext	Context `[get]`

IEventSource	ParentSource `[get]`
	Gets an optional parent source. More...

IEnumerable< KeyValuePair< string, object > >	Metadata `[get]`
	Gets the list of metadata associated to the source. More...

Properties inherited from Deveel.Data.Sql.Triggers.ITableStateHandler
OldNewTableState	TableState `[get]`
	Gets an object that olds the state before and after a table event. More...

Private Member Functions
	~Transaction ()

void	AddInternalTables ()

void	AssertNotReadOnly ()

void	Finish ()

void	Dispose (bool disposing)

void ICallbackHandler.	OnCallbackAttached (TableCommitCallback callback)

void ICallbackHandler.	OnCallbackDetached (TableCommitCallback callback)

Static Private Member Functions
static	Transaction ()

Private Attributes
List< TableCommitCallback >	callbacks

Action< TableCommitInfo >	commitActions

readonly bool	dbReadOnly

Static Private Attributes
static readonly TableInfo[]	IntTableInfo

Detailed Description

The system implementation of a transaction model that handles isolated operations within a database context.

See also: ITransaction

Definition at line 35 of file Transaction.cs.

Constructor & Destructor Documentation

Deveel.Data.Transactions.Transaction.Transaction	(	ITransactionContext	context,
		Database	database,
		int	commitId,
		IsolationLevel	isolation,
		IEnumerable< TableSource >	committedTables,
		IEnumerable< IIndexSet >	indexSets
	)

inlinepackage

Definition at line 44 of file Transaction.cs.

                                                                                                                                                                                                  {
             CommitId = commitId;
             Database = database;
             Isolation = isolation;
             Context = context;
 
             context.RegisterInstance<ITransaction>(this);
 
             Registry = new TransactionRegistry(this);
             TableManager.AddVisibleTables(committedTables, indexSets);
 
             AddInternalTables();
 
             TableState = new OldNewTableState();
 
             IsClosed = false;
 
             Database.TransactionFactory.OpenTransactions.AddTransaction(this);
 
             this.CurrentSchema(database.Context.DefaultSchema());
             this.ReadOnly(database.Context.ReadOnly());
             this.AutoCommit(database.Context.AutoCommit());
             this.IgnoreIdentifiersCase(database.Context.IgnoreIdentifiersCase());
             this.ParameterStyle(QueryParameterStyle.Marker);
         }

Deveel.Data.Transactions.Transaction.Transaction	(	ITransactionContext	context,
		Database	database,
		int	commitId,
		IsolationLevel	isolation
	)

inlinepackage

Definition at line 70 of file Transaction.cs.

71 : this(context, database, commitId, isolation, new TableSource[0], new IIndexSet[0]) {

72 }

Deveel.Data.Sql.Tables.TableSource

Definition: TableSource.cs:34

Deveel.Data.Index.IIndexSet

An object that access to a set of indexes.

Definition: IIndexSet.cs:27

Deveel.Data.Transactions.Transaction.~Transaction ( )

inlineprivate

Definition at line 74 of file Transaction.cs.

                        {
             Dispose(false);
         }

static Deveel.Data.Transactions.Transaction.Transaction ( )

inlinestaticprivate

Definition at line 78 of file Transaction.cs.

                              {
             IntTableInfo = new TableInfo[9];
             IntTableInfo[0] = SystemSchema.TableInfoTableInfo;
             IntTableInfo[1] = SystemSchema.TableColumnsTableInfo;
             IntTableInfo[2] = SystemSchema.ProductInfoTableInfo;
             IntTableInfo[3] = SystemSchema.VariablesTableInfo;
             IntTableInfo[4] = SystemSchema.StatisticsTableInfo;
             IntTableInfo[5] = SystemSchema.SessionInfoTableInfo;
             IntTableInfo[6] = SystemSchema.OpenSessionsTableInfo;
             IntTableInfo[7] = SystemSchema.SqlTypesTableInfo;
             IntTableInfo[8] = SystemSchema.PrivilegesTableInfo;
         }

Member Function Documentation

void Deveel.Data.Transactions.Transaction.AddInternalTables ( )

inlineprivate

Definition at line 155 of file Transaction.cs.

                                          {
             TableManager.AddInternalTables(new TransactionTableContainer(this, IntTableInfo));
 
             // OLD and NEW system tables (if applicable)
             TableManager.AddInternalTables(new OldAndNewTableContainer(this));
 
             // Model views as tables (obviously)
             TableManager.AddInternalTables(ViewManager.CreateInternalTableInfo());
 
             //tableManager.AddInternalTables(routineManager.CreateInternalTableInfo());
 
             // Model sequences as tables
             TableManager.AddInternalTables(SequenceManager.TableContainer);
 
             // Model triggers as tables
             TableManager.AddInternalTables(TriggerManager.CreateTriggersTableContainer());
         }

void Deveel.Data.Transactions.Transaction.AssertNotReadOnly ( )

inlineprivate

Definition at line 174 of file Transaction.cs.

                                          {
             if (this.ReadOnly())
                 throw new TransactionException(TransactionErrorCodes.ReadOnly, "The transaction is in read-only mode.");
         }

void Deveel.Data.Transactions.Transaction.Commit ( )

inline

Commits all write operation done during the lifetime of this transaction and invalidates it.

See also: TransactionExtensions.ReadOnly(ITransaction), Rollback

When a transaction is disposed without explicitly calling Commit, all the operations are implicitly rolled-back.

Implements Deveel.Data.Transactions.ITransaction.

Definition at line 179 of file Transaction.cs.

                              {
             if (!IsClosed) {
                 try {
                     var touchedTables = TableManager.AccessedTables.ToList();
                     var visibleTables = TableManager.GetVisibleTables().ToList();
                     var selected = TableManager.SelectedTables.ToArray();
                     TableComposite.Commit(this, visibleTables, selected, touchedTables, Registry, commitActions);
 
 
                 } finally {
                     Finish();
                 }
             }
         }

void Deveel.Data.Transactions.Transaction.Dispose ( )

inline

Definition at line 251 of file Transaction.cs.

                               {
             Dispose(true);
             GC.SuppressFinalize(this);
         }

void Deveel.Data.Transactions.Transaction.Dispose ( bool disposing )

inlineprivate

Definition at line 256 of file Transaction.cs.

                                              {
             if (disposing) {
                 //if (!IsClosed)
                 //  Rollback();
                 // TODO: review this ...
                 Finish();
             }
         }

void Deveel.Data.Transactions.Transaction.Finish ( )

inlineprivate

Definition at line 208 of file Transaction.cs.

                               {
             try {
                 // Dispose all the table we touched
                 try {
                     TableManager.Dispose();
 
                     if (Context != null)
                         Context.Dispose();
 
                 } catch (Exception ex) {
                     this.OnError(ex);
                 }
 
                 Registry = null;
 
                 if (callbacks != null) {
                     foreach (var callback in callbacks) {
                         callback.OnTransactionEnd();
                         callback.DetachFrom(this);
                     }
                 }
 
                 callbacks = null;
                 Context = null;
 
                 // Dispose all the objects in the transaction
             } finally {
                 IsClosed = true;
             }
         }

void ICallbackHandler. Deveel.Data.Transactions.Transaction.OnCallbackAttached ( TableCommitCallback callback )

inlineprivate

Implements Deveel.Data.Transactions.ICallbackHandler.

Definition at line 655 of file Transaction.cs.

                                                                                {
             if (callbacks == null)
                 callbacks = new List<TableCommitCallback>();
 
             callbacks.Add(callback);
         }

void ICallbackHandler. Deveel.Data.Transactions.Transaction.OnCallbackDetached ( TableCommitCallback callback )

inlineprivate

Implements Deveel.Data.Transactions.ICallbackHandler.

Definition at line 662 of file Transaction.cs.

                                                                                {
             if (callbacks == null)
                 return;
 
             for (int i = callbacks.Count - 1; i >= 0; i--) {
                 var other = callbacks[i];
                 if (other.TableName.Equals(callback.TableName))
                     callbacks.RemoveAt(i);
             }
         }

void Deveel.Data.Transactions.Transaction.RegisterOnCommit ( Action< TableCommitInfo > action )

inline

Implements Deveel.Data.Transactions.ITransaction.

Definition at line 194 of file Transaction.cs.

                                                                      {
             if (commitActions == null) {
                 commitActions = action;
             } else {
                 commitActions = Delegate.Combine(commitActions, action) as Action<TableCommitInfo>;
             }
         }

void Deveel.Data.Transactions.Transaction.Rollback ( )

inline

Rollback any write operations done during the lifetime of this transaction and invalidates it.

When a transaction is disposed without explicitly calling Commit, all the operations are implicitly rolled-back.

See also: IDisposable.Dispose, Commit, TransactionExtensions.ReadOnly(Deveel.Data.Transactions.ITransaction)

Implements Deveel.Data.Transactions.ITransaction.

Definition at line 239 of file Transaction.cs.

                                {
             if (!IsClosed) {
                 try {
                     var touchedTables = TableManager.AccessedTables.ToList();
                     TableComposite.Rollback(this, touchedTables, Registry);
                 } finally {
                     IsClosed = true;
                     Finish();
                 }
             }
         }

void Deveel.Data.Transactions.Transaction.SetTableState ( OldNewTableState tableState )

inline

Implements Deveel.Data.Sql.Triggers.ITableStateHandler.

Definition at line 101 of file Transaction.cs.

                                                                {
             TableState = tableState;
         }

void Deveel.Data.Transactions.Transaction.UnregisterOnCommit ( Action< TableCommitInfo > action )

inline

Implements Deveel.Data.Transactions.ITransaction.

Definition at line 202 of file Transaction.cs.

                                                                        {
             if (commitActions != null)
                 commitActions = Delegate.Remove(commitActions, action) as Action<TableCommitInfo>;
         }

Member Data Documentation

List<TableCommitCallback> Deveel.Data.Transactions.Transaction.callbacks

private

Definition at line 36 of file Transaction.cs.

Action<TableCommitInfo> Deveel.Data.Transactions.Transaction.commitActions

private

Definition at line 38 of file Transaction.cs.

readonly bool Deveel.Data.Transactions.Transaction.dbReadOnly

private

Definition at line 42 of file Transaction.cs.

readonly TableInfo [] Deveel.Data.Transactions.Transaction.IntTableInfo

staticprivate

Definition at line 40 of file Transaction.cs.

Property Documentation

int Deveel.Data.Transactions.Transaction.CommitId

getprivate set

Definition at line 91 of file Transaction.cs.

ITransactionContext Deveel.Data.Transactions.Transaction.Context

getprivate set

Definition at line 99 of file Transaction.cs.

IContext IEventSource. Deveel.Data.Transactions.Transaction.Context

getprivate

Definition at line 125 of file Transaction.cs.

IDatabase ITransaction. Deveel.Data.Transactions.Transaction.Database

getprivate

Definition at line 105 of file Transaction.cs.

Database Deveel.Data.Transactions.Transaction.Database

getprivate set

Definition at line 109 of file Transaction.cs.

IDatabaseContext Deveel.Data.Transactions.Transaction.DatabaseContext

get

Definition at line 129 of file Transaction.cs.

bool Deveel.Data.Transactions.Transaction.IsClosed

getsetprivate

Definition at line 95 of file Transaction.cs.

IsolationLevel Deveel.Data.Transactions.Transaction.Isolation

getprivate set

Definition at line 93 of file Transaction.cs.

IEnumerable<KeyValuePair<string, object> > IEventSource. Deveel.Data.Transactions.Transaction.Metadata

getprivate

Definition at line 115 of file Transaction.cs.

IEventSource IEventSource. Deveel.Data.Transactions.Transaction.ParentSource

getprivate

Definition at line 111 of file Transaction.cs.

TransactionRegistry Deveel.Data.Transactions.Transaction.Registry

getprivate set

Definition at line 149 of file Transaction.cs.

SequenceManager Deveel.Data.Transactions.Transaction.SequenceManager

getprivate

Definition at line 137 of file Transaction.cs.

TableSourceComposite Deveel.Data.Transactions.Transaction.TableComposite

getprivate

Definition at line 133 of file Transaction.cs.

TableManager Deveel.Data.Transactions.Transaction.TableManager

getprivate

Definition at line 151 of file Transaction.cs.

OldNewTableState Deveel.Data.Transactions.Transaction.TableState

getprivate set

Definition at line 97 of file Transaction.cs.

TriggerManager Deveel.Data.Transactions.Transaction.TriggerManager

getprivate

Definition at line 145 of file Transaction.cs.

ViewManager Deveel.Data.Transactions.Transaction.ViewManager

getprivate

Definition at line 141 of file Transaction.cs.

The documentation for this class was generated from the following file:

/var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Transactions/Transaction.cs

Classes

Public Member Functions

Package Functions

Properties

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation