Inheritance diagram for Deveel.Data.TableSourceComposite:

Public Member Functions
	TableSourceComposite (Database database)

void	Dispose ()

bool	Exists ()

void	Open ()

void	Create ()

void	Close ()

void	Delete ()

int	NextTableId ()

Public Attributes
const string	ObjectStoreName = "lob_store"

Package Functions
void	MinimalCreate ()

TableSource	CreateTableSource (TableInfo tableInfo, bool temporary)

TableSource	GetTableSource (int tableId)

void	Commit (Transaction transaction, IList< ITableSource > visibleTables, IEnumerable< ITableSource > selectedFromTables, IEnumerable< IMutableTable > touchedTables, TransactionRegistry journal, Action< TableCommitInfo > commitActions)

void	Rollback (Transaction transaction, IList< IMutableTable > touchedTables, TransactionRegistry journal)

TableSource	CopySourceTable (TableSource tableSource, IIndexSet indexSet)

ITransaction	CreateTransaction (IsolationLevel isolation)

void	RegisterOnCommit (Action< TableCommitInfo > action)

void	UnregisterOnCommit (Action< TableCommitInfo > action)

void	CloseTransaction (ITransaction transaction)

void	CommitToTables (IEnumerable< int > createdTables, IEnumerable< int > droppedTables)

bool	ContainsVisibleResource (int resourceId)

Properties
Database	Database `[get, private set]`

IDatabaseContext	DatabaseContext `[get]`

IStoreSystem	StoreSystem `[get]`

int	CurrentCommitId `[get, private set]`

bool	IsReadOnly `[get]`

bool	IsClosed `[get]`

TableStateStore	StateStore `[get, set]`

string	StateStoreName `[get, set]`

IObjectStore	LargeObjectStore `[get, set]`

Private Member Functions
	~TableSourceComposite ()

void	ReadVisibleTables ()

void	ReadDroppedTables ()

TableSource	LoadTableSource (int tableId, string tableName)

void	MarkUncommitted (int tableId)

void	Dispose (bool disposing)

void	Setup ()

void	InitObjectStore ()

void	CleanUp ()

bool	CloseAndDropTable (string tableFileName)

void	CloseTable (string sourceName, bool pendingDrop)

void	InitSystemSchema ()

void	CreateSystemSchema ()

ITableSource ITableSourceComposite.	CreateTableSource (TableInfo tableInfo, bool temporary)

void	OnCommitModification (ObjectName objName, IEnumerable< int > addedRows, IEnumerable< int > removedRows)

ITableSource ITableSourceComposite.	CopySourceTable (ITableSource tableSource, IIndexSet indexSet)

Private Attributes
readonly object	commitLock = new object()

Dictionary< int, TableSource >	tableSources

List< TransactionObjectState >	objectStates

IStoreSystem	tempStoreSystem

IStore	lobStore

IStore	stateStore

const string	StateStorePostfix = "_sf"

Action< TableCommitInfo >	tableCommitCallback

Detailed Description

Definition at line 29 of file TableSourceComposite.cs.

Constructor & Destructor Documentation

Deveel.Data.TableSourceComposite.TableSourceComposite ( Database database )

inline

Definition at line 43 of file TableSourceComposite.cs.

                                                        {
             Database = database;
 
             tempStoreSystem = new InMemoryStorageSystem();
             objectStates = new List<TransactionObjectState>();
 
             StateStoreName = String.Format("{0}{1}", database.Name, StateStorePostfix);
 
             Setup();
         }

Deveel.Data.TableSourceComposite.~TableSourceComposite ( )

inlineprivate

Definition at line 54 of file TableSourceComposite.cs.

                                 {
             Dispose(false);
         }

Member Function Documentation

void Deveel.Data.TableSourceComposite.CleanUp ( )

inlineprivate

Definition at line 238 of file TableSourceComposite.cs.

                                {
             lock (commitLock) {
                 if (IsClosed)
                     return;
 
                 // If no open transactions on the database, then clean up.
                 if (Database.TransactionFactory.OpenTransactions.Count == 0) {
                     var deleteList = StateStore.GetDeleteList().ToArray();
                     if (deleteList.Length > 0) {
                         int dropCount = 0;
 
                         for (int i = deleteList.Length - 1; i >= 0; --i) {
                             var tableName = deleteList[i].SourceName;
                             CloseTable(tableName, true);
                         }
 
                         for (int i = deleteList.Length - 1; i >= 0; --i) {
                             string tableName = deleteList[i].SourceName;
                             bool dropped = CloseAndDropTable(tableName);
                             // If we managed to drop the table, remove from the list.
                             if (dropped) {
                                 StateStore.RemoveDeleteResource(tableName);
                                 ++dropCount;
                             }
                         }
 
                         // If we dropped a table, commit an update to the conglomerate state.
                         if (dropCount > 0)
                             StateStore.Flush();
                     }
                 }
             }
         }

void Deveel.Data.TableSourceComposite.Close ( )

inline

Definition at line 413 of file TableSourceComposite.cs.

                             {
             lock (commitLock) {
                 CleanUp();
 
                 StoreSystem.SetCheckPoint();
 
                 // Go through and close all the committed tables.
                 foreach (var source in tableSources.Values) {
                     source.Close(false);
                 }
 
                 StateStore.Flush();
                 StoreSystem.CloseStore(stateStore);
 
                 tableSources = null;
             }
 
             // Release the storage system
             StoreSystem.Unlock(StateStoreName);
 
             if (LargeObjectStore != null)
                 StoreSystem.CloseStore(lobStore);
         }

bool Deveel.Data.TableSourceComposite.CloseAndDropTable ( string tableFileName )

inlineprivate

Definition at line 272 of file TableSourceComposite.cs.

                                                              {
             // Find the table with this file name.
             int? tableId = null;
             foreach (var source in tableSources.Values) {
                 if (source.StoreIdentity.Equals(tableFileName)) {
                     if (source.IsRootLocked)
                         return false;
 
                     if (!source.Drop())
                         return false;
 
                     tableId = source.TableId;
                 }
             }
 
             if (tableId != null)
                 tableSources.Remove(tableId.Value);
 
             return false;
         }

void Deveel.Data.TableSourceComposite.CloseTable	(	string	sourceName,
		bool	pendingDrop
	)

inlineprivate

Definition at line 293 of file TableSourceComposite.cs.

                                                                      {
             // Find the table with this file name.
             foreach (var source in tableSources.Values) {
                 if (source.SourceName.Equals(sourceName)) {
                     if (source.IsRootLocked)
                         break;
 
                     source.Close(pendingDrop);
                     break;
                 }
             }
         }

void Deveel.Data.TableSourceComposite.CloseTransaction ( ITransaction transaction )

inlinepackage

Definition at line 657 of file TableSourceComposite.cs.

                                                                  {
             bool lastTransaction;
             // Closing must happen under a commit Lock.
             lock (commitLock) {
                 Database.TransactionFactory.OpenTransactions.RemoveTransaction(transaction);
                 // Increment the commit id.
                 ++CurrentCommitId;
                 // Was that the last transaction?
                 lastTransaction = Database.TransactionFactory.OpenTransactions.Count == 0;
             }
 
             // If last transaction then schedule a clean up event.
             if (lastTransaction) {
                 try {
                     CleanUp();
                 } catch (IOException) {
                     // TODO: Register the error ...
                 }
             }
         }

void Deveel.Data.TableSourceComposite.Commit	(	Transaction	transaction,
		IList< ITableSource >	visibleTables,
		IEnumerable< ITableSource >	selectedFromTables,
		IEnumerable< IMutableTable >	touchedTables,
		TransactionRegistry	journal,
		Action< TableCommitInfo >	commitActions
	)

inlinepackage

Definition at line 519 of file TableSourceComposite.cs.

                                                                                                                                          {
 
             var state = new TransactionWork(this, transaction, selectedFromTables, touchedTables, journal);
 
             // Exit early if nothing changed (this is a Read-only transaction)
             if (!state.HasChanges) {
                 CloseTransaction(state.Transaction);
                 return;
             }
 
             lock (commitLock) {
                 var changedTablesList = state.Commit(objectStates, commitActions);
 
                 // Flush the journals up to the minimum commit id for all the tables
                 // that this transaction changed.
                 long minCommitId = Database.TransactionFactory.OpenTransactions.MinimumCommitId(null);
                 foreach (var master in changedTablesList) {
                     master.MergeChanges(minCommitId);
                 }
                 int nsjsz = objectStates.Count;
                 for (int i = nsjsz - 1; i >= 0; --i) {
                     var namespaceJournal = objectStates[i];
                     // Remove if the commit id for the journal is less than the minimum
                     // commit id
                     if (namespaceJournal.CommitId < minCommitId) {
                         objectStates.RemoveAt(i);
                     }
                 }
 
                 // Set a check point in the store system.  This means that the
                 // persistance state is now stable.
                 StoreSystem.SetCheckPoint();
             }
         }

void Deveel.Data.TableSourceComposite.CommitToTables	(	IEnumerable< int >	createdTables,
		IEnumerable< int >	droppedTables
	)

inlinepackage

Definition at line 678 of file TableSourceComposite.cs.

                                                                                                      {
             // Add created tables to the committed tables list.
             foreach (int createdTable in createdTables) {
                 // For all created tables, add to the visible list and remove from the
                 // delete list in the state store.
                 var t = GetTableSource(createdTable);
                 var resource = new TableStateStore.TableState(t.TableId, t.SourceName);
                 StateStore.AddVisibleResource(resource);
                 StateStore.RemoveDeleteResource(resource.SourceName);
             }
 
             // Remove dropped tables from the committed tables list.
             foreach (int droppedTable in droppedTables) {
                 // For all dropped tables, add to the delete list and remove from the
                 // visible list in the state store.
                 var t = GetTableSource(droppedTable);
                 var resource = new TableStateStore.TableState(t.TableId, t.SourceName);
                 StateStore.AddDeleteResource(resource);
                 StateStore.RemoveVisibleResource(resource.SourceName);
             }
 
             try {
                 StateStore.Flush();
             } catch (IOException e) {
                 throw new InvalidOperationException("IO Error: " + e.Message, e);
             }
         }

bool Deveel.Data.TableSourceComposite.ContainsVisibleResource ( int resourceId )

inlinepackage

Definition at line 706 of file TableSourceComposite.cs.

                                                               {
             return StateStore.ContainsVisibleResource(resourceId);
         }

ITableSource ITableSourceComposite. Deveel.Data.TableSourceComposite.CopySourceTable	(	ITableSource	tableSource,
		IIndexSet	indexSet
	)

inlineprivate

Implements Deveel.Data.Sql.Tables.ITableSourceComposite.

Definition at line 590 of file TableSourceComposite.cs.

                                                                                                          {
             return CopySourceTable((TableSource) tableSource, indexSet);
         }

TableSource Deveel.Data.TableSourceComposite.CopySourceTable	(	TableSource	tableSource,
		IIndexSet	indexSet
	)

inlinepackage

Definition at line 594 of file TableSourceComposite.cs.

                                                                                           {
             lock (commitLock) {
                 try {
                     // The unique id that identifies this table,
                     int tableId = NextTableId();
                     var sourceName = tableSource.SourceName;
 
                     // Create the object.
                     var masterTable = new TableSource(this, StoreSystem, LargeObjectStore, tableId, sourceName);
 
                     masterTable.CopyFrom(tableId, tableSource, indexSet);
 
                     // Add to the list of all tables.
                     tableSources.Add(tableId, masterTable);
 
                     // Add this to the list of deleted tables,
                     MarkUncommitted(tableId);
 
                     // Commit this
                     StateStore.Flush();
 
                     // And return it.
                     return masterTable;
                 } catch (IOException e) {
                     throw new Exception(String.Format("Unable to copy source table '{0}' because of an error.", tableSource.TableInfo.TableName), e);
                 }
             }
         }

void Deveel.Data.TableSourceComposite.Create ( )

inline

Definition at line 339 of file TableSourceComposite.cs.

                              {
             MinimalCreate();
 
             // Initialize the conglomerate system tables.
             InitSystemSchema();
 
             // Commit the state
             StateStore.Flush();
         }

void Deveel.Data.TableSourceComposite.CreateSystemSchema ( )

inlineprivate

Definition at line 394 of file TableSourceComposite.cs.

                                           {
             // Create the transaction
             ITransaction transaction = null;
 
             try {
                 transaction = Database.CreateSafeTransaction(IsolationLevel.Serializable);
                 transaction.CreateSystemSchema();
 
                 // Commit and close the transaction.
                 transaction.Commit();
                 transaction = null;
             } catch (TransactionException e) {
                 throw new InvalidOperationException("Transaction Exception creating composite.", e);
             } finally {
                 if (transaction != null)
                     transaction.Rollback();
             }
         }

ITableSource ITableSourceComposite. Deveel.Data.TableSourceComposite.CreateTableSource	(	TableInfo	tableInfo,
		bool	temporary
	)

inlineprivate

Implements Deveel.Data.Sql.Tables.ITableSourceComposite.

Definition at line 464 of file TableSourceComposite.cs.

                                                                                                   {
             return CreateTableSource(tableInfo, temporary);
         }

TableSource Deveel.Data.TableSourceComposite.CreateTableSource	(	TableInfo	tableInfo,
		bool	temporary
	)

inlinepackage

Implements Deveel.Data.Sql.Tables.ITableSourceComposite.

Definition at line 468 of file TableSourceComposite.cs.

                                                                                     {
             lock (commitLock) {
                 try {
                     int tableId = NextTableId();
 
                     // Create the object.
                     var storeSystem = StoreSystem;
                     if (temporary)
                         storeSystem = tempStoreSystem;
 
                     var source = new TableSource(this, storeSystem, LargeObjectStore, tableId, tableInfo.TableName.FullName);
                     source.Create(tableInfo);
 
                     tableSources.Add(tableId, source);
 
                     if (!temporary) {
                         MarkUncommitted(tableId);
 
                         StateStore.Flush();
                     }
 
                     // And return it.
                     return source;
                 } catch (IOException e) {
                     throw new InvalidOperationException(String.Format("Unable to create source for table '{0}'.", tableInfo.TableName), e);
                 }
             }
         }

ITransaction Deveel.Data.TableSourceComposite.CreateTransaction ( IsolationLevel isolation )

inlinepackage

Definition at line 623 of file TableSourceComposite.cs.

                                                                           {
             var thisCommittedTables = new List<TableSource>();
 
             // Don't let a commit happen while we are looking at this.
             lock (commitLock) {
                 int thisCommitId = CurrentCommitId;
                 var committedTableList = StateStore.GetVisibleList();
                 thisCommittedTables.AddRange(committedTableList.Select(resource => GetTableSource(resource.TableId)));
 
                 // Create a set of IIndexSet for all the tables in this transaction.
                 var indexInfo = (thisCommittedTables.Select(mtable => mtable.CreateIndexSet())).ToList();
 
                 // Create a context for the transaction to handle the isolated storage of variables and services
                 var context = DatabaseContext.CreateTransactionContext();
 
                 // Create the transaction and record it in the open transactions list.
                 return new Transaction(context, Database, thisCommitId, isolation, thisCommittedTables, indexInfo);
             }
         }

void Deveel.Data.TableSourceComposite.Delete ( )

inline

Definition at line 437 of file TableSourceComposite.cs.

                              {
             lock (commitLock) {
                 // We possibly have things to clean up.
                 CleanUp();
 
                 // Go through and delete and close all the committed tables.
                 foreach (var source in tableSources.Values)
                     source.Drop();
 
                 // Delete the state file
                 StateStore.Flush();
                 StoreSystem.CloseStore(stateStore);
                 StoreSystem.DeleteStore(stateStore);
 
                 // Delete the blob store
                 if (LargeObjectStore != null) {
                     StoreSystem.CloseStore(lobStore);
                     StoreSystem.DeleteStore(lobStore);
                 }
 
                 tableSources = null;
             }
 
             // Release the storage system.
             StoreSystem.Unlock(StateStoreName);
         }

void Deveel.Data.TableSourceComposite.Dispose ( bool disposing )

inlineprivate

Definition at line 169 of file TableSourceComposite.cs.

                                              {
             if (disposing) {
                 if (!IsClosed)
                     Close();
 
                 if (lobStore != null)
                     lobStore.Dispose();
                 if (stateStore != null)
                     stateStore.Dispose();
 
                 if (tempStoreSystem != null)
                     tempStoreSystem.Dispose();
 
                 tempStoreSystem = null;
                 lobStore = null;
             }
         }

void Deveel.Data.TableSourceComposite.Dispose ( )

inline

Definition at line 187 of file TableSourceComposite.cs.

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

bool Deveel.Data.TableSourceComposite.Exists ( )

inline

Definition at line 306 of file TableSourceComposite.cs.

                              {
             return StoreSystem.StoreExists(StateStoreName);
         }

TableSource Deveel.Data.TableSourceComposite.GetTableSource ( int tableId )

inlinepackage

Definition at line 497 of file TableSourceComposite.cs.

                                                          {
             lock (commitLock) {
                 if (tableSources == null)
                     return null;
 
                 TableSource source;
                 if (!tableSources.TryGetValue(tableId, out source))
                     throw new ObjectNotFoundException(
                         String.Format("Could not find any source for table with id {0} in this composite.", tableId));
 
                 return source;
             }
         }

void Deveel.Data.TableSourceComposite.InitObjectStore ( )

inlineprivate

Definition at line 199 of file TableSourceComposite.cs.

                                        {
             // Does the file already exist?
             bool blobStoreExists = StoreSystem.StoreExists(ObjectStoreName);
             // If the blob store doesn't exist and we are read_only, we can't do
             // anything further so simply return.
             if (!blobStoreExists && IsReadOnly) {
                 return;
             }
 
             // The blob store,
             if (blobStoreExists) {
                 lobStore = StoreSystem.OpenStore(ObjectStoreName);
             } else {
                 lobStore = StoreSystem.CreateStore(ObjectStoreName);
             }
 
             try {
                 lobStore.Lock();
 
                 // TODO: have multiple BLOB stores
                 LargeObjectStore = new ObjectStore(0, lobStore);
 
                 // Get the 64 byte fixed area
                 var fixedArea = lobStore.GetArea(-1, false);
                 // If the blob store didn't exist then we need to create it here,
                 if (!blobStoreExists) {
                     long headerP = LargeObjectStore.Create();
                     fixedArea.WriteInt8(headerP);
                     fixedArea.Flush();
                 } else {
                     // Otherwise we need to initialize the blob store
                     long headerP = fixedArea.ReadInt8();
                     LargeObjectStore.Open(headerP);
                 }
             } finally {
                 lobStore.Unlock();
             }
         }

void Deveel.Data.TableSourceComposite.InitSystemSchema ( )

inlineprivate

Definition at line 349 of file TableSourceComposite.cs.

                                         {
             using (var transaction = Database.CreateSafeTransaction(IsolationLevel.Serializable)) {
                 try {
                     SystemSchema.Setup(transaction);
                     transaction.Commit();
                 } catch (Exception ex) {
                     throw new InvalidOperationException("Transaction Exception initializing tables.", ex);
                 }
             }
         }

TableSource Deveel.Data.TableSourceComposite.LoadTableSource	(	int	tableId,
		string	tableName
	)

inlineprivate

Definition at line 136 of file TableSourceComposite.cs.

                                                                            {
             var source = new TableSource(this, StoreSystem, LargeObjectStore, tableId, tableName);
             if (!source.Exists())
                 return null;
 
             return source;
         }

void Deveel.Data.TableSourceComposite.MarkUncommitted ( int tableId )

inlineprivate

Definition at line 144 of file TableSourceComposite.cs.

                                                   {
             var masterTable = GetTableSource(tableId);
             StateStore.AddDeleteResource(new TableStateStore.TableState(tableId, masterTable.SourceName));
         }

void Deveel.Data.TableSourceComposite.MinimalCreate ( )

inlinepackage

Definition at line 360 of file TableSourceComposite.cs.

                                       {
             if (Exists())
                 throw new IOException("Composite already exists");
 
             // Lock the store system (generates an IOException if exclusive Lock
             // can not be made).
             if (!IsReadOnly) {
                 StoreSystem.Lock(StateStoreName);
             }
 
             // Create/Open the state store
             stateStore = StoreSystem.CreateStore(StateStoreName);
             try {
                 stateStore.Lock();
 
                 StateStore = new TableStateStore(stateStore);
                 long headP = StateStore.Create();
                 // Get the fixed area
                 var fixedArea = stateStore.GetArea(-1);
                 fixedArea.WriteInt8(headP);
                 fixedArea.Flush();
             } finally {
                 stateStore.Unlock();
             }
 
             Setup();
 
             // Init the conglomerate blob store
             InitObjectStore();
 
             // Create the system table (but don't initialize)
             CreateSystemSchema();
         }

int Deveel.Data.TableSourceComposite.NextTableId ( )

inline

Definition at line 511 of file TableSourceComposite.cs.

                                  {
             return StateStore.NextTableId();
         }

void Deveel.Data.TableSourceComposite.OnCommitModification	(	ObjectName	objName,
		IEnumerable< int >	addedRows,
		IEnumerable< int >	removedRows
	)

inlineprivate

Definition at line 515 of file TableSourceComposite.cs.

                                                                                                                         {
             
         }

void Deveel.Data.TableSourceComposite.Open ( )

inline

Definition at line 310 of file TableSourceComposite.cs.

                            {
             if (!Exists())
                 throw new IOException("Table composite does not exist");
 
             // Check the file Lock
             if (!IsReadOnly) {
                 // Obtain the Lock (generate error if this is not possible)
                 StoreSystem.Lock(StateStoreName);
             }
 
             // Open the state store
             stateStore = StoreSystem.OpenStore(StateStoreName);
             StateStore = new TableStateStore(stateStore);
 
             // Get the fixed 64 byte area.
             var fixedArea = stateStore.GetArea(-1);
             long headP = fixedArea.ReadInt8();
             StateStore.Open(headP);
 
             Setup();
 
             InitObjectStore();
 
             ReadVisibleTables();
             ReadDroppedTables();
 
             CleanUp();
         }

void Deveel.Data.TableSourceComposite.ReadDroppedTables ( )

inlineprivate

Definition at line 108 of file TableSourceComposite.cs.

                                          {
             lock (commitLock) {
                 // The list of all dropped tables from the state file
                 var tables = StateStore.GetDeleteList();
 
                 // For each visible table
                 foreach (var resource in tables) {
                     int tableId =resource.TableId;
                     string tableName = resource.SourceName;
 
                     // Load the master table from the resource information
                     var source = LoadTableSource(tableId, tableName);
 
                     // File wasn't found so remove from the delete resources
                     if (source == null) {
                         StateStore.RemoveDeleteResource(tableName);
                     } else {
                         source.Open();
 
                         // Add the table to the table list
                         tableSources.Add(tableId, source);
                     }
                 }
 
                 StateStore.Flush();
             }
         }

void Deveel.Data.TableSourceComposite.ReadVisibleTables ( )

inlineprivate

Definition at line 84 of file TableSourceComposite.cs.

                                          {
             lock (commitLock) {
                 var tables = StateStore.GetVisibleList();
 
                 // For each visible table
                 foreach (var resource in tables) {
                     var tableId = resource.TableId;
                     var sourceName = resource.SourceName;
 
                     // TODO: add a table source type?
 
                     // Load the master table from the resource information
                     var source = LoadTableSource(tableId, sourceName);
 
                     if (source == null)
                         throw new InvalidOperationException(String.Format("Table {0} was not found.", sourceName));
 
                     source.Open();
 
                     tableSources.Add(tableId, source);
                 }
             }
         }

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

inlinepackage

Definition at line 645 of file TableSourceComposite.cs.

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

void Deveel.Data.TableSourceComposite.Rollback	(	Transaction	transaction,
		IList< IMutableTable >	touchedTables,
		TransactionRegistry	journal
	)

inlinepackage

Definition at line 556 of file TableSourceComposite.cs.

                                                                                                                          {
             // Go through the journal.  Any rows added should be marked as deleted
             // in the respective master table.
 
             // Get individual journals for updates made to tables in this
             // transaction.
             // The list MasterTableJournal
             var journalList = new List<TableEventRegistry>();
             for (int i = 0; i < touchedTables.Count; ++i) {
                 var tableJournal = touchedTables[i].EventRegistry;
                 if (tableJournal.EventCount > 0) // Check the journal has entries.
                     journalList.Add(tableJournal);
             }
 
             var changedTables = journalList.ToArray();
 
             lock (commitLock) {
                 try {
                     // For each change to each table,
                     foreach (var changeJournal in changedTables) {
                         // The table the changes were made to.
                         int tableId = changeJournal.TableId;
                         // Get the master table with this table id.
                         var master = GetTableSource(tableId);
                         // Commit the rollback on the table.
                         master.RollbackTransactionChange(changeJournal);
                     }
                 } finally {
                     // Notify the conglomerate that this transaction has closed.
                     CloseTransaction(transaction);
                 }
             }
         }

void Deveel.Data.TableSourceComposite.Setup ( )

inlineprivate

Definition at line 192 of file TableSourceComposite.cs.

                              {
             lock (this) {
                 CurrentCommitId = 0;
                 tableSources = new Dictionary<int, TableSource>();              
             }
         }

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

inlinepackage

Definition at line 653 of file TableSourceComposite.cs.

                                                                          {
             tableCommitCallback = Delegate.Remove(tableCommitCallback, action) as Action<TableCommitInfo>;
         }

Member Data Documentation

readonly object Deveel.Data.TableSourceComposite.commitLock = new object()

private

Definition at line 30 of file TableSourceComposite.cs.

IStore Deveel.Data.TableSourceComposite.lobStore

private

Definition at line 36 of file TableSourceComposite.cs.

List<TransactionObjectState> Deveel.Data.TableSourceComposite.objectStates

private

Definition at line 33 of file TableSourceComposite.cs.

const string Deveel.Data.TableSourceComposite.ObjectStoreName = "lob_store"

Definition at line 41 of file TableSourceComposite.cs.

IStore Deveel.Data.TableSourceComposite.stateStore

private

Definition at line 37 of file TableSourceComposite.cs.

const string Deveel.Data.TableSourceComposite.StateStorePostfix = "_sf"

private

Definition at line 39 of file TableSourceComposite.cs.

Action<TableCommitInfo> Deveel.Data.TableSourceComposite.tableCommitCallback

private

Definition at line 643 of file TableSourceComposite.cs.

Dictionary<int, TableSource> Deveel.Data.TableSourceComposite.tableSources

private

Definition at line 31 of file TableSourceComposite.cs.

IStoreSystem Deveel.Data.TableSourceComposite.tempStoreSystem

private

Definition at line 35 of file TableSourceComposite.cs.

Property Documentation

int Deveel.Data.TableSourceComposite.CurrentCommitId

getprivate set

Definition at line 68 of file TableSourceComposite.cs.

Database Deveel.Data.TableSourceComposite.Database

getprivate set

Definition at line 58 of file TableSourceComposite.cs.

IDatabaseContext Deveel.Data.TableSourceComposite.DatabaseContext

get

Definition at line 60 of file TableSourceComposite.cs.

bool Deveel.Data.TableSourceComposite.IsClosed

getprivate

Definition at line 74 of file TableSourceComposite.cs.

bool Deveel.Data.TableSourceComposite.IsReadOnly

getprivate

Definition at line 70 of file TableSourceComposite.cs.

IObjectStore Deveel.Data.TableSourceComposite.LargeObjectStore

getsetprivate

Definition at line 82 of file TableSourceComposite.cs.

TableStateStore Deveel.Data.TableSourceComposite.StateStore

getsetprivate

Definition at line 78 of file TableSourceComposite.cs.

string Deveel.Data.TableSourceComposite.StateStoreName

getsetprivate

Definition at line 80 of file TableSourceComposite.cs.

IStoreSystem Deveel.Data.TableSourceComposite.StoreSystem

getprivate

Definition at line 64 of file TableSourceComposite.cs.

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

/var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Sql.Tables/TableSourceComposite.cs

Public Member Functions

Public Attributes

Package Functions

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation