public static bool TestCommitClash(this ITableEventRegistry registry, ITableEventRegistry other, out RowRemoveConflict conflict)
{
lock (registry) {
// Very nasty search here...
foreach (var rowEvent in registry.OfType <TableRowEvent>())
{
if (rowEvent.EventType == TableRowEventType.Remove)
{
var rowNum = rowEvent.RowNumber;
foreach (var otherRowEvent in other.OfType <TableRowEvent>())
{
if (otherRowEvent.RowNumber == rowNum &&
otherRowEvent.EventType == TableRowEventType.Remove)
{
conflict = new RowRemoveConflict(registry.TableId, rowNum);
return(true);
}
}
}
}
conflict = new RowRemoveConflict();
return(false);
}
}
public static long[] GetAddedRows(this ITableEventRegistry registry)
{
lock (registry) {
var list = new List <long>();
foreach (var tableEvent in registry.OfType <TableRowEvent>())
{
var eventType = tableEvent.EventType;
if (eventType == TableRowEventType.Add ||
eventType == TableRowEventType.UpdateAdd)
{
list.Add(tableEvent.RowNumber);
}
else if (eventType == TableRowEventType.Remove ||
eventType == TableRowEventType.UpdateRemove)
{
var index = list.IndexOf(tableEvent.RowNumber);
if (index != -1)
{
list.RemoveAt(index);
}
}
}
return(list.ToArray());
}
}
public static long[] GetRemovedRows(this ITableEventRegistry registry)
{
lock (registry) {
var list = new List <long>();
foreach (var tableEvent in registry.OfType <TableRowEvent>())
{
if (tableEvent.EventType == TableRowEventType.Remove ||
tableEvent.EventType == TableRowEventType.UpdateRemove)
{
list.Add(tableEvent.RowNumber);
}
}
return(list.ToArray());
}
}
internal void RollbackTransactionChange(ITableEventRegistry registry)
{
lock (this) {
// ASSERT: Can't do this is source is Read only.
if (IsReadOnly)
{
throw new InvalidOperationException("Can't rollback transaction journal, table is Read only.");
}
// Any rows added in the journal are marked as committed deleted and the
// journal is then discarded.
try {
// Mark all rows in the data_store as appropriate to the changes.
foreach (var tableEvent in registry)
{
if (tableEvent is TableRowEvent)
{
var rowEvent = (TableRowEvent)tableEvent;
if (rowEvent.EventType == TableRowEventType.Add)
{
var oldState = WriteRecordState(rowEvent.RowNumber, RecordState.CommittedRemoved);
if (oldState != RecordState.Uncommitted)
{
WriteRecordState(rowEvent.RowNumber, oldState);
throw new InvalidOperationException($"Record {rowEvent.RowNumber} was not in an uncommitted state.");
}
GC.DeleteRow(rowEvent.RowNumber);
}
}
}
} catch (IOException e) {
throw new InvalidOperationException("IO Error: " + e.Message, e);
}
}
}
internal void CommitTransactionChange(long commitId, ITableEventRegistry change, IRowIndexSet indexSet)
{
lock (this) {
// ASSERT: Can't do this if source is Read only.
if (IsReadOnly)
{
throw new InvalidOperationException("Can't commit transaction journal, table is Read only.");
}
// CHECK!
// TODO: change.CommitId = commitId;
try {
// Add this registry to the multi version table indices log
Registries.AddRegistry(change);
// Write the modified index set to the index store
// (Updates the index file)
CommitIndexSet(indexSet);
// Update the state of the committed added data to the file system.
// (Updates data to the allocation file)
//
// ISSUE: This can add up to a lot of changes to the allocation file and
// the runtime could potentially be terminated in the middle of
// the update. If an interruption happens the allocation information
// may be incorrectly flagged. The type of corruption this would
// result in would be;
// + From an 'update' the updated record may disappear.
// + From a 'delete' the deleted record may not delete.
// + From an 'insert' the inserted record may not insert.
//
// Note, the possibility of this type of corruption occuring has been
// minimized as best as possible given the current architecture.
// Also note that is not possible for a table file to become corrupted
// beyond recovery from this issue.
foreach (var entry in change)
{
if (entry is TableRowEvent)
{
var rowEvent = (TableRowEvent)entry;
var rowIndex = rowEvent.RowNumber;
if (rowEvent.EventType == TableRowEventType.Add)
{
// Record commit added
var oldType = WriteRecordState(rowIndex, RecordState.CommittedAdded);
// Check the record was in an uncommitted state before we changed
// it.
if (oldType != RecordState.Uncommitted)
{
WriteRecordState(rowIndex, oldType);
throw new InvalidOperationException($"Record {rowIndex} of table {TableName} was not in an uncommitted state!");
}
}
else if (rowEvent.EventType == TableRowEventType.Remove)
{
// Record commit removed
var oldType = WriteRecordState(rowIndex, RecordState.CommittedRemoved);
// Check the record was in an added state before we removed it.
if (oldType != RecordState.CommittedAdded)
{
WriteRecordState(rowIndex, oldType);
throw new InvalidOperationException($"Record {rowIndex} of table {TableName} was not in an added state!");
}
// Notify collector that this row has been marked as deleted.
GC.DeleteRow(rowIndex);
}
}
}
} catch (IOException e) {
throw new InvalidOperationException("IO Error: " + e.Message, e);
}
}
}
public void Rollback(ITableEventRegistry registry)
{
throw new NotImplementedException();
}
public IMutableTable GetMutableTable(ITransaction transaction, ITableEventRegistry registry)
{
throw new NotImplementedException();
}