Inheritance diagram for Deveel.Data.Transactions.TransactionTable:

Classes
class	RowEnumerator

Public Member Functions
	TransactionTable (ITransaction transaction, TableSource tableSource, TableEventRegistry eventRegistry)

DataObject	GetValue (long rowNumber, int columnOffset)
	Gets a single cell within the table that is located at the given column offset and row. More...

ColumnIndex	GetIndex (int columnOffset)
	Gets an index for given column that can be used to select values from this table. More...

IEnumerator< Row >	GetEnumerator ()

void	Dispose ()

RowId	AddRow (Row row)
	Persists a new row to the table. More...

void	UpdateRow (Row row)
	Updates the values of a row into the table. More...

bool	RemoveRow (RowId rowId)
	Deletes row identified by the given coordinates from the table. More...

void	FlushIndexes ()
	Flushes all changes made on this table to the backing index scheme. More...

void	AssertConstraints ()
	Performs all constraint integrity checks and actions to any modifications based on any changes that happened to the table since that last call to this method. More...

void	AddLock ()

void	RemoveLock ()

Properties
int	ColumnCount `[get]`

IContext	Context `[get, private set]`

TableInfo	TableInfo `[get]`

int	RowCount `[get]`

IIndex	RowIndex `[get]`

ITransaction	Transaction `[get, private set]`

TableSource	TableSource `[get, private set]`

TableEventRegistry	EventRegistry `[get, private set]`

int	TableId `[get]`

ObjectName	FullName `[get]`

DbObjectType	ObjectType `[get]`

object ILockable.	RefId `[get]`

Properties inherited from Deveel.Data.Sql.Tables.IMutableTable
TableEventRegistry	EventRegistry `[get]`

Properties inherited from Deveel.Data.Sql.Tables.ITable
IContext	Context `[get]`

TableInfo	TableInfo `[get]`
	Gets the metadata information of the table, used to resolve the column sources. More...

int	RowCount `[get]`
	Gets the total number of rows in the table. More...

Properties inherited from Deveel.Data.Sql.IDbObject
ObjectName	FullName `[get]`
	Gets the fully qualified name of the object used to resolve it uniquely within the database. More...

DbObjectType	ObjectType `[get]`
	Gets the type of database object that the implementation is for More...

Properties inherited from Deveel.Data.Transactions.ILockable
object	RefId `[get]`

Private Member Functions
	~TransactionTable ()

void	AssertNotDisposed ()

void	EnsureRowIndexListCurrent ()

void	EnsureColumnIndexCurrent (int column)

IEnumerator IEnumerable.	GetEnumerator ()

void	Dispose (bool disposing)

void	ExecuteUpdateReferentialAction (ConstraintInfo constraint, DataObject[] originalKey, DataObject[] newKey, IQuery context)

void	ExecuteDeleteReferentialAction (ConstraintInfo constraint, DataObject[] originalKey, IQuery context)

void ILockable.	Released (Lock @lock)

void ILockable.	Acquired (Lock @lock)

Private Attributes
int	rowListRebuild

IIndex	rowIndex

int[]	indexRebuilds

IIndexSet	indexSet

ColumnIndex[]	columnIndexes

int	lastEntryRICheck

bool	disposed

Detailed Description

Definition at line 28 of file TransactionTable.cs.

Constructor & Destructor Documentation

Deveel.Data.Transactions.TransactionTable.TransactionTable	(	ITransaction	transaction,
		TableSource	tableSource,
		TableEventRegistry	eventRegistry
	)

inline

Definition at line 40 of file TransactionTable.cs.

                                                                                                                      {
             Transaction = transaction;
             TableSource = tableSource;
             EventRegistry = eventRegistry;
             Context = tableSource.DatabaseContext;
             indexSet = transaction.GetTableManager().GetIndexSetForTable(tableSource);
             rowListRebuild = 0;
 
             var colCount = ColumnCount;
             indexRebuilds = new int[colCount];
             columnIndexes = new ColumnIndex[colCount];
             lastEntryRICheck = eventRegistry.EventCount;
         }

Deveel.Data.Transactions.TransactionTable.~TransactionTable ( )

inlineprivate

Definition at line 54 of file TransactionTable.cs.

                             {
             Dispose(false);
         }

Member Function Documentation

void ILockable. Deveel.Data.Transactions.TransactionTable.Acquired ( Lock @ lock )

inlineprivate

Implements Deveel.Data.Transactions.ILockable.

Definition at line 660 of file TransactionTable.cs.

                                             {
             // TODO: increment a count ref to prevent disposal?
         }

void Deveel.Data.Transactions.TransactionTable.AddLock ( )

inline

Implements Deveel.Data.Sql.Tables.IMutableTable.

Definition at line 606 of file TransactionTable.cs.

                               {
             AssertNotDisposed();
 
             TableSource.AddLock();
         }

RowId Deveel.Data.Transactions.TransactionTable.AddRow ( Row row )

inline

Persists a new row to the table.

The row to be added must belong to the table context, otherwise an exception will be thrown.

Parameters

row	The row to be persisted.

Returns: Returns a RowId that is the pointer to the row established in the table.

Exceptions

ArgumentException	If the gven row does not belong to the table context.
ArgumentNullException	If the given row is `null`.

Implements Deveel.Data.Sql.Tables.IMutableTable.

Definition at line 243 of file TransactionTable.cs.

                                      {
             AssertNotDisposed();
 
             if (Transaction.ReadOnly())
                 throw new Exception("Transaction is Read only.");
 
             if (TableSource.IsReadOnly)
                 throw new InvalidOperationException("Can not add row - table is read-only.");
 
             int rowNum;
             try {
                 rowNum = TableSource.AddRow(row);
             } catch (Exception ex) {
                 throw new InvalidOperationException(
                     String.Format("Unknown error when adding a row to the table '{0}'.", TableInfo.TableName), ex);
             }
 
             row.SetRowNumber(rowNum);
 
             // Note this doesn't need to be synchronized because we are exclusive on
             // this table.
 
             EventRegistry.Register(new TableRowEvent(TableId, rowNum, TableRowEventType.Add));
 
             return new RowId(TableId, rowNum);
         }

void Deveel.Data.Transactions.TransactionTable.AssertConstraints ( )

inline

Performs all constraint integrity checks and actions to any modifications based on any changes that happened to the table since that last call to this method.

It is important that is called after any call to AddRow, RemoveRow or UpdateRow.

Any constraints that are marked as ConstraintDeferrability.InitiallyImmediate are checked when this is called, otherwise the constraint is checked at commit time.

Any referential actions are performed when this method is called. If a referential action causes a modification to another table, this method is recursively called on the table modified.

If a referential integrity constraint is violated and a referential action is unable to maintain the integrity of the database, any changes made to the table are reverted.

Implements Deveel.Data.Sql.Tables.IMutableTable.

Definition at line 414 of file TransactionTable.cs.

                                         {
             AssertNotDisposed();
 
             try {
                 // Early exit condition
                 if (lastEntryRICheck == EventRegistry.EventCount)
                     return;
 
                 // This table name
                 var tableInfo = TableInfo;
                 var tName = tableInfo.TableName;
 
                 using (var session = new SystemSession(Transaction, tName.ParentName)) {
                     using (var context = session.CreateQuery()) {
 
                         // Are there any added, deleted or updated entries in the journal since
                         // we last checked?
                         List<int> rowsUpdated = new List<int>();
                         List<int> rowsDeleted = new List<int>();
                         List<int> rowsAdded = new List<int>();
 
                         var events = EventRegistry.Skip(lastEntryRICheck);
                         foreach (var tableEvent in events.OfType<TableRowEvent>()) {
                             var rowNum = tableEvent.RowNumber;
                             if (tableEvent.EventType == TableRowEventType.Remove ||
                                 tableEvent.EventType == TableRowEventType.UpdateRemove) {
                                 rowsDeleted.Add(rowNum);
 
                                 var index = rowsAdded.IndexOf(rowNum);
                                 if (index != -1)
                                     rowsAdded.RemoveAt(index);
                             } else if (tableEvent.EventType == TableRowEventType.Add ||
                                        tableEvent.EventType == TableRowEventType.UpdateAdd) {
                                 rowsAdded.Add(rowNum);
                             }
 
                             if (tableEvent.EventType == TableRowEventType.UpdateAdd ||
                                 tableEvent.EventType == TableRowEventType.UpdateRemove)
                                 rowsUpdated.Add(rowNum);
                         }
 
                         // Were there any updates or deletes?
                         if (rowsDeleted.Count > 0) {
                             // Get all references on this table
                             var foreignConstraints = Transaction.QueryTableImportedForeignKeys(tName);
 
                             // For each foreign constraint
                             foreach (var constraint in foreignConstraints) {
                                 // For each deleted/updated record in the table,
                                 foreach (var rowNum in rowsDeleted) {
                                     // What was the key before it was updated/deleted
                                     var cols = tableInfo.IndexOfColumns(constraint.ForeignColumnNames).ToArray();
 
                                     var originalKey = new DataObject[cols.Length];
                                     int nullCount = 0;
                                     for (int p = 0; p < cols.Length; ++p) {
                                         originalKey[p] = GetValue(rowNum, cols[p]);
                                         if (originalKey[p].IsNull) {
                                             ++nullCount;
                                         }
                                     }
 
                                     // Check the original key isn't null
                                     if (nullCount != cols.Length) {
                                         // Is is an update?
                                         int updateIndex = rowsUpdated.IndexOf(rowNum);
                                         if (updateIndex != -1) {
                                             // Yes, this is an update
                                             int rowIndexAdd = rowsUpdated[updateIndex + 1];
 
                                             // It must be an update, so first see if the change caused any
                                             // of the keys to change.
                                             bool keyChanged = false;
                                             var keyUpdatedTo = new DataObject[cols.Length];
                                             for (int p = 0; p < cols.Length; ++p) {
                                                 keyUpdatedTo[p] = GetValue(rowIndexAdd, cols[p]);
                                                 if (originalKey[p].CompareTo(keyUpdatedTo[p]) != 0) {
                                                     keyChanged = true;
                                                 }
                                             }
                                             if (keyChanged) {
                                                 // Allow the delete, and execute the action,
                                                 // What did the key update to?
                                                 ExecuteUpdateReferentialAction(constraint, originalKey, keyUpdatedTo, context);
                                             }
 
                                             // If the key didn't change, we don't need to do anything.
                                         } else {
                                             // No, so it must be a delete,
                                             // This will look at the referencee table and if it contains
                                             // the key, work out what to do with it.
                                             ExecuteDeleteReferentialAction(constraint, originalKey, context);
                                         }
 
                                     } // If the key isn't null
 
                                 } // for each deleted rows
 
                             } // for each foreign key reference to this table
 
                         }
 
                         // Were there any rows added (that weren't deleted)?
                         if (rowsAdded.Count > 0) {
                             int[] rowIndices = rowsAdded.ToArray();
 
                             // Check for any field constraint violations in the added rows
                             Transaction.CheckFieldConstraintViolations(this, rowIndices);
 
                             // Check this table, adding the given row_index, immediate
                             Transaction.CheckAddConstraintViolations(this, rowIndices, ConstraintDeferrability.InitiallyImmediate);
                         }
                     }
                 }
             } catch (ConstraintViolationException) {
                 // If a constraint violation, roll back the changes since the last
                 // check.
                 int rollbackPoint = EventRegistry.EventCount - lastEntryRICheck;
                 if (rowListRebuild <= rollbackPoint) {
                     EventRegistry.Rollback(rollbackPoint);
                 } else {
                     // TODO: emit a warning
                 }
 
                 throw;
             } finally {
                 // Make sure we update the 'last_entry_ri_check' variable
                 lastEntryRICheck = EventRegistry.EventCount;
             }
         }

void Deveel.Data.Transactions.TransactionTable.AssertNotDisposed ( )

inlineprivate

Definition at line 84 of file TransactionTable.cs.

                                          {
             if (disposed)
                 throw new ObjectDisposedException("Table", "The table was disposed.");
         }

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

inlineprivate

Definition at line 214 of file TransactionTable.cs.

                                              {
             if (!disposed) {
                 if (disposing) {
                     // Dispose and invalidate the indexes
                     // This is really a safety measure to ensure the index can't be
                     // used outside the scope of the lifetime of this object.
                     if (columnIndexes != null) {
                         foreach (var columnIndex in columnIndexes) {
                             if (columnIndex != null)
                                 columnIndex.Dispose();
                         }
                     }
                 }
 
                 columnIndexes = null;
                 rowIndex = null;
                 EventRegistry = null;
                 indexRebuilds = null;
                 indexSet = null;
                 Transaction = null;
                 disposed = true;
             }
         }

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

inline

Definition at line 238 of file TransactionTable.cs.

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

void Deveel.Data.Transactions.TransactionTable.EnsureColumnIndexCurrent ( int column )

inlineprivate

Definition at line 120 of file TransactionTable.cs.

                                                           {
             var index = columnIndexes[column];
 
             // NOTE: We should be assured that no Write operations can occur over
             //   this section of code because writes are exclusive operations
             //   within a transaction.
             // Are there journal entries pending on this scheme since?
             int rebuildIndex = indexRebuilds[column];
             int journalCount = EventRegistry.EventCount;
             while (rebuildIndex < journalCount) {
                 var tableEvent = EventRegistry.GetEvent(rebuildIndex);
                 if (tableEvent is TableRowEvent) {
                     var rowEvent = (TableRowEvent) tableEvent;
                     if (rowEvent.EventType == TableRowEventType.Add ||
                         rowEvent.EventType == TableRowEventType.UpdateAdd) {
                         index.Insert(rowEvent.RowNumber);
                     } else if (rowEvent.EventType == TableRowEventType.Remove ||
                                rowEvent.EventType == TableRowEventType.UpdateRemove) {
                         index.Remove(rowEvent.RowNumber);
                     } else {
                         throw new InvalidOperationException(String.Format("Table row event type {0} is invalid.", rowEvent.EventType));
                     }
                 }
 
                 ++rebuildIndex;
             }
 
             indexRebuilds[column] = rebuildIndex;
         }

void Deveel.Data.Transactions.TransactionTable.EnsureRowIndexListCurrent ( )

inlineprivate

Definition at line 89 of file TransactionTable.cs.

                                                  {
             int rebuildIndex = rowListRebuild;
             int journalCount = EventRegistry.EventCount;
             while (rebuildIndex < journalCount) {
                 var command = EventRegistry.GetEvent(rebuildIndex);
                 if (command is TableRowEvent) {
                     var rowEvent = (TableRowEvent) command;
                     var index = rowEvent.RowNumber;
 
                     if (rowEvent.EventType == TableRowEventType.Add ||
                         rowEvent.EventType == TableRowEventType.UpdateAdd) {
                         // Add to 'row_list'.
                         if (!RowIndex.UniqueInsertSort(index))
                             throw new InvalidOperationException(String.Format("Row index already used in this table ({0})", index));
                     } else if (rowEvent.EventType == TableRowEventType.Remove ||
                                rowEvent.EventType == TableRowEventType.UpdateRemove) {
                         // Remove from 'row_list'
                         if (!RowIndex.RemoveSort(index))
                             throw new InvalidOperationException("Row index removed that wasn't in this table!");
                     } else {
                         throw new InvalidOperationException(String.Format("Table row event type {0} is invalid.", rowEvent.EventType));
                     }
                 }
 
                 ++rebuildIndex;
             }
 
             // It's now current (row_list_rebuild == journal_count);
             rowListRebuild = rebuildIndex;
         }

void Deveel.Data.Transactions.TransactionTable.ExecuteDeleteReferentialAction	(	ConstraintInfo	constraint,
		DataObject[]	originalKey,
		IQuery	context
	)

inlineprivate

Definition at line 546 of file TransactionTable.cs.

                                                                                                                          {
             var deleteRule = constraint.OnDelete;
             if (deleteRule == ForeignKeyAction.NoAction &&
                 constraint.Deferred != ConstraintDeferrability.InitiallyImmediate) {
                 // Constraint check is deferred
                 return;
             }
 
             // So either delete rule is not NO ACTION, or if it is we are initially
             // immediate.
             var keyTable = Transaction.GetMutableTable(constraint.TableName);
             var tableInfo = keyTable.TableInfo;
             var keyCols = tableInfo.IndexOfColumns(constraint.ColumnNames).ToArray();
             var keyEntries = keyTable.FindKeys(keyCols, originalKey).ToList();
 
             // Are there keys effected?
             if (keyEntries.Count > 0) {
                 if (deleteRule == ForeignKeyAction.NoAction) {
                     // Throw an exception;
                     throw new ConstraintViolationException(
                         SqlModelErrorCodes.ForeignKeyViolation,
                         constraint.Deferred.AsDebugString() +
                         " foreign key constraint violation on delete (" +
                         constraint.ConstraintName + ") Columns = " +
                         constraint.TableName + "( " +
                         String.Join(", ", constraint.ColumnNames) +
                         " ) -> " + constraint.ForeignTable.FullName + "( " +
                         String.Join(", ", constraint.ForeignColumnNames) +
                         " )");
                 }
 
                 // Perform a referential action on each updated key
                 foreach (int rowNum in keyEntries) {
                     var dataRow = new Row(keyTable, new RowId(tableInfo.Id, rowNum));
                     dataRow.SetFromTable();
 
                     if (deleteRule == ForeignKeyAction.Cascade) {
                         // Cascade the removal of the referenced rows
                         keyTable.RemoveRow(dataRow.RowId);
                     } else if (deleteRule == ForeignKeyAction.SetNull) {
                         for (int n = 0; n < keyCols.Length; ++n) {
                             dataRow.SetNull(keyCols[n]);
                         }
                         keyTable.UpdateRow(dataRow);
                     } else if (deleteRule == ForeignKeyAction.SetDefault) {
                         for (int n = 0; n < keyCols.Length; ++n) {
                             dataRow.SetDefault(keyCols[n], context);
                         }
                         keyTable.UpdateRow(dataRow);
                     } else {
                         throw new Exception("Do not understand referential action: " + deleteRule);
                     }
                 }
 
                 // Check referential integrity of modified table,
                 keyTable.AssertConstraints();
             }
 
         }

void Deveel.Data.Transactions.TransactionTable.ExecuteUpdateReferentialAction	(	ConstraintInfo	constraint,
		DataObject[]	originalKey,
		DataObject[]	newKey,
		IQuery	context
	)

inlineprivate

Definition at line 351 of file TransactionTable.cs.

                             {
             var updateRule = constraint.OnUpdate;
             if (updateRule == ForeignKeyAction.NoAction &&
                 constraint.Deferred != ConstraintDeferrability.InitiallyImmediate) {
                 // Constraint check is deferred
                 return;
             }
 
             // So either update rule is not NO ACTION, or if it is we are initially
             // immediate.
             var keyTable = Transaction.GetMutableTable(constraint.TableName);
             var tableInfo = keyTable.TableInfo;
             var keyCols = tableInfo.IndexOfColumns(constraint.ColumnNames).ToArray();
             var keyEntries = keyTable.FindKeys(keyCols, originalKey);
 
             // Are there keys effected?
             if (keyEntries.Any()) {
                 if (updateRule == ForeignKeyAction.NoAction)
 
                     // Throw an exception;
                     throw new ConstraintViolationException(
                         SqlModelErrorCodes.ForeignKeyViolation,
                         constraint.Deferred.AsDebugString() +
                         " foreign key constraint violation on update (" +
                         constraint.ConstraintName + ") Columns = " +
                         constraint.TableName + "( " +
                         String.Join(", ", constraint.ColumnNames) +
                         " ) -> " + constraint.ForeignTable.FullName + "( " +
                         String.Join(", ", constraint.ForeignColumnNames) +
                         " )");
 
                 // Perform a referential action on each updated key
                 foreach (int rowNum in keyEntries) {
                     var dataRow = new Row(keyTable, new RowId(keyTable.TableInfo.Id, rowNum));
                     dataRow.SetFromTable();
 
                     if (updateRule == ForeignKeyAction.Cascade) {
                         // Update the keys
                         for (int n = 0; n < keyCols.Length; ++n) {
                             dataRow.SetValue(keyCols[n], newKey[n]);
                         }
                         keyTable.UpdateRow(dataRow);
                     } else if (updateRule == ForeignKeyAction.SetNull) {
                         for (int n = 0; n < keyCols.Length; ++n) {
                             dataRow.SetNull(keyCols[n]);
                         }
                         keyTable.UpdateRow(dataRow);
                     } else if (updateRule == ForeignKeyAction.SetDefault) {
                         for (int n = 0; n < keyCols.Length; ++n) {
                             dataRow.SetDefault(keyCols[n], context);
                         }
                         keyTable.UpdateRow(dataRow);
                     } else {
                         throw new Exception("Do not understand referential action: " + updateRule);
                     }
                 }
 
                 // Check referential integrity of modified table,
                 keyTable.AssertConstraints();
             }
         }

void Deveel.Data.Transactions.TransactionTable.FlushIndexes ( )

inline

Flushes all changes made on this table to the backing index scheme.

This is used during the commit phase of this objects lifetime. The transaction control mechanism has found that there are no clashes and now we need to commit the current table view to the conglomerate. Because this object may not update index information immediately, we call this to flush all the changes to the table to the backing index set.

When this method returns, the backing index-set of this view will be completely up to date.

Implements Deveel.Data.Sql.Tables.IMutableTable.

Definition at line 340 of file TransactionTable.cs.

                                    {
             AssertNotDisposed();
 
             EnsureRowIndexListCurrent();
 
             // This will flush all of the column indexes
             for (int i = 0; i < columnIndexes.Length; ++i) {
                 GetIndex(i);
             }
         }

IEnumerator<Row> Deveel.Data.Transactions.TransactionTable.GetEnumerator ( )

inline

Definition at line 203 of file TransactionTable.cs.

                                                 {
             // Ensure the row list is up to date.
             EnsureRowIndexListCurrent();
             var enumerator = RowIndex.GetEnumerator();
             return new RowEnumerator(this, enumerator);
         }

IEnumerator IEnumerable. Deveel.Data.Transactions.TransactionTable.GetEnumerator ( )

inlineprivate

Definition at line 210 of file TransactionTable.cs.

                                                 {
             return GetEnumerator();
         }

ColumnIndex Deveel.Data.Transactions.TransactionTable.GetIndex ( int columnOffset )

inline

Gets an index for given column that can be used to select values from this table.

Parameters

columnOffset The zero-based offset of the column which to get the index.

Returns: Returns an instance of ColumnIndex that is used to select a subset of rows from the table.

Implements Deveel.Data.Sql.Tables.ITable.

Definition at line 156 of file TransactionTable.cs.

                                                       {
             AssertNotDisposed();
 
             if (columnOffset < 0 || columnOffset >= ColumnCount)
                 throw new ArgumentOutOfRangeException("columnOffset");
 
             var index = columnIndexes[columnOffset];
 
             // Cache the scheme in this object.
             if (index == null) {
                 index = TableSource.CreateColumnIndex(indexSet, this, columnOffset);
                 columnIndexes[columnOffset] = index;
             }
 
             // Update the underlying scheme to the most current version.
             EnsureColumnIndexCurrent(columnOffset);
 
             return index;
         }

DataObject Deveel.Data.Transactions.TransactionTable.GetValue	(	long	rowNumber,
		int	columnOffset
	)

inline

Gets a single cell within the table that is located at the given column offset and row.

Parameters

rowNumber	The unique number of the row where the cell is located.
columnOffset	The zero-based offset of the column of the cell to return.

Returns: Returns an instance of DataObject that is contained in the cell located by the row and column coordinates provided.

Exceptions

ArgumentOutOfRangeException If the given columnOffset is less than zero or greater or equal than the number of columns defined in the table metadata.

See also: Tables.TableInfo.IndexOfColumn(string)

Implements Deveel.Data.Sql.Tables.ITable.

Definition at line 150 of file TransactionTable.cs.

                                                                      {
             AssertNotDisposed();
 
             return TableSource.GetValue((int) rowNumber, columnOffset);
         }

void ILockable. Deveel.Data.Transactions.TransactionTable.Released ( Lock @ lock )

inlineprivate

Implements Deveel.Data.Transactions.ILockable.

Definition at line 656 of file TransactionTable.cs.

                                             {
             // TODO: decrement a count ref to disposal?
         }

void Deveel.Data.Transactions.TransactionTable.RemoveLock ( )

inline

Implements Deveel.Data.Sql.Tables.IMutableTable.

Definition at line 612 of file TransactionTable.cs.

                                  {
             AssertNotDisposed();
 
             TableSource.RemoveLock();
         }

bool Deveel.Data.Transactions.TransactionTable.RemoveRow ( RowId rowId )

inline

Deletes row identified by the given coordinates from the table.

Parameters

rowId The unique identifier of the row to be removed.

Returns: Returns true if the row identified was found and removed, false otherwise.

Exceptions

ArgumentException Thrown if the given rowId does not belong to this table.

Implements Deveel.Data.Sql.Tables.IMutableTable.

Definition at line 310 of file TransactionTable.cs.

                                            {
             AssertNotDisposed();
 
             if (rowId.IsNull)
                 throw new ArgumentNullException("rowId");
 
             if (rowId.TableId != TableId)
                 throw new ArgumentException("The table part of the ROWID is not this table.");
             if (rowId.RowNumber < 0)
                 throw new ArgumentException("The number part of the ROWID is not valid for remove.");
 
             if (Transaction.ReadOnly())
                 throw new Exception("Transaction is Read only.");
 
             // Check this isn't a Read only source
             if (TableSource.IsReadOnly)
                 throw new InvalidOperationException("Can not remove row - table is Read only.");
 
             // NOTE: This must <b>NOT</b> call 'RemoveRow' in TableSource.
             //   We do not want to delete a row permanently from the underlying
             //   file because the transaction using this data source may yet decide
             //   to roll back the change and not delete the row.
 
             // Note this doesn't need to be synchronized because we are exclusive on
             // this table.
             EventRegistry.Register(new TableRowEvent(rowId.TableId, rowId.RowNumber, TableRowEventType.Remove));
 
             return true;
         }

void Deveel.Data.Transactions.TransactionTable.UpdateRow ( Row row )

inline

Updates the values of a row into the table.

Parameters

row	The object containing the values to update.

Exceptions

ArgumentNullException If the given row is null.

Implements Deveel.Data.Sql.Tables.IMutableTable.

Definition at line 270 of file TransactionTable.cs.

                                        {
             AssertNotDisposed();
 
             if (Transaction.ReadOnly())
                 throw new Exception("Transaction is Read only.");
 
             // Check this isn't a Read only source
             if (TableSource.IsReadOnly)
                 throw new InvalidOperationException("Can not update row - table is read-only.");
 
             if (row.RowId.IsNull)
                 throw new ArgumentException("The ROWID cannot be null in an update.");
 
             if (row.RowId.TableId != TableId)
                 throw new ArgumentException("The row was not created from this table.");
 
             var rowNum = row.RowId.RowNumber;
 
             if (rowNum < 0)
                 throw new ArgumentException("The number part of the ROWID is invalid.");
 
             // Note this doesn't need to be synchronized because we are exclusive on
             // this table.
             EventRegistry.Register(new TableRowEvent(TableId, rowNum, TableRowEventType.UpdateRemove));
 
             int newRowIndex;
 
             try {
                 newRowIndex = TableSource.AddRow(row);
             } catch (IOException e) {
                 throw new InvalidOperationException("IO Error: " + e.Message, e);
             }
 
             row.SetRowNumber(newRowIndex);
 
             // Note this doesn't need to be synchronized because we are exclusive on
             // this table.
             EventRegistry.Register(new TableRowEvent(TableId, newRowIndex, TableRowEventType.UpdateAdd));
         }

Member Data Documentation

ColumnIndex [] Deveel.Data.Transactions.TransactionTable.columnIndexes

private

Definition at line 34 of file TransactionTable.cs.

bool Deveel.Data.Transactions.TransactionTable.disposed

private

Definition at line 38 of file TransactionTable.cs.

int [] Deveel.Data.Transactions.TransactionTable.indexRebuilds

private

Definition at line 32 of file TransactionTable.cs.

IIndexSet Deveel.Data.Transactions.TransactionTable.indexSet

private

Definition at line 33 of file TransactionTable.cs.

int Deveel.Data.Transactions.TransactionTable.lastEntryRICheck

private

Definition at line 36 of file TransactionTable.cs.

IIndex Deveel.Data.Transactions.TransactionTable.rowIndex

private

Definition at line 30 of file TransactionTable.cs.

int Deveel.Data.Transactions.TransactionTable.rowListRebuild

private

Definition at line 29 of file TransactionTable.cs.

Property Documentation

int Deveel.Data.Transactions.TransactionTable.ColumnCount

get

Definition at line 58 of file TransactionTable.cs.

IContext Deveel.Data.Transactions.TransactionTable.Context

getprivate set

Definition at line 65 of file TransactionTable.cs.

TableEventRegistry Deveel.Data.Transactions.TransactionTable.EventRegistry

getprivate set

Definition at line 189 of file TransactionTable.cs.

ObjectName Deveel.Data.Transactions.TransactionTable.FullName

get

Definition at line 195 of file TransactionTable.cs.

DbObjectType Deveel.Data.Transactions.TransactionTable.ObjectType

get

Definition at line 199 of file TransactionTable.cs.

object ILockable. Deveel.Data.Transactions.TransactionTable.RefId

getprivate

Definition at line 652 of file TransactionTable.cs.

int Deveel.Data.Transactions.TransactionTable.RowCount

get

Definition at line 74 of file TransactionTable.cs.

IIndex Deveel.Data.Transactions.TransactionTable.RowIndex

getprivate

Definition at line 176 of file TransactionTable.cs.

int Deveel.Data.Transactions.TransactionTable.TableId

getprivate

Definition at line 191 of file TransactionTable.cs.

TableInfo Deveel.Data.Transactions.TransactionTable.TableInfo

get

Definition at line 67 of file TransactionTable.cs.

TableSource Deveel.Data.Transactions.TransactionTable.TableSource

getprivate set

Definition at line 187 of file TransactionTable.cs.

ITransaction Deveel.Data.Transactions.TransactionTable.Transaction

getprivate set

Definition at line 185 of file TransactionTable.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/TransactionTable.cs

Classes

Public Member Functions

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation