public void Remove <T>(T value, long index, IIndexedObjectComparer <T> c)
{
CheckReadOnly();
// Search for the position of the last value in the set,
long p1, p2;
SearchFirstAndLast(value, c, out p1, out p2);
// If the value isn't found report the error,
if (p1 < 0)
{
throw new ApplicationException("Value '" + value + "' was not found in the set.");
}
IIndexCursor cursor = GetCursor(p1, p2);
while (cursor.MoveNext())
{
if (cursor.Current == index)
{
// Remove the value and return
cursor.Remove();
return;
}
}
}
public JoinedTable(ITable[] tables, IIndex<RowId>[] lists)
: base(tables)
{
if (tables.Length != lists.Length)
throw new ApplicationException("'tables' and 'lists' size do not match.");
tableLists = new IIndexCursor<RowId>[lists.Length];
// Work out the row count (all the lists should be the same size).
long rcount = lists[0].Count;
for (int i = 0; i < lists.Length; ++i) {
if (rcount != lists[i].Count)
throw new ApplicationException("List " + i + " is not equal size to rest in list.");
tableLists[i] = lists[i].GetCursor();
}
rowCount = rcount;
}
public DataAddress Commit(IPathConnection connection, DataAddress rootNode)
{
// Turn the proposal into a proposed_transaction,
ITransaction t = connection.CreateTransaction(rootNode);
DbTransaction proposedTransaction = new DbTransaction(null, rootNode, t);
try {
// Fetch the base root from the proposed_transaction log,
TextReader reader = proposedTransaction.GetLogReader();
string baseRootStr = reader.ReadLine();
// If 'base_root_str' is "no base root" then it means we are commiting
// an introduced transaction that is not an iteration of previous
// snapshots.
if (baseRootStr.Equals("no base root"))
{
// In which case, we publish the proposed snapshot unconditionally
// and return.
connection.Publish(rootNode);
return(rootNode);
}
DataAddress baseRoot = DataAddress.Parse(baseRootStr);
// Find all the entries since this base
DataAddress[] roots = connection.GetSnapshots(baseRoot);
// If there are no roots, we can publish the proposed_transaction
// unconditionally
if (roots.Length == 0)
{
connection.Publish(rootNode);
return(rootNode);
}
// Check historical log for clashes, and if none, replay the commands
// in the log.
// For each previous root, we build a structure that can answer the
// following questions;
// * Is file [name] created, deleted or changed in this root?
// * Is table [name] created or deleted in this root?
// * Is table [name] structurally changed in this root?
// * Has row [rowid] been deleted in table [name] in this root?
RootEvents[] rootEventSet = new RootEvents[roots.Length];
int i = 0;
// TODO: RootEvents is pre-computed information which we could
// store in a local cache for some speed improvements, so we don't
// need to walk through through the same data multiple times.
foreach (DataAddress root in roots)
{
RootEvents rootEvents = new RootEvents();
rootEventSet[i] = rootEvents;
++i;
// Create a transaction object for this root
ITransaction rootT = connection.CreateTransaction(root);
DbTransaction rootTransaction = new DbTransaction(null, root, rootT);
// Make a reader object for the log,
TextReader rootReader = rootTransaction.GetLogReader();
// Read the base root from this transaction,
String baseRootParent = rootReader.ReadLine();
// If 'bast_root_parent' is 'no base root' then it means a version
// has been introduced that is not an iteration of previous
// snapshots. In this case, it is not possible to merge updates
// therefore we generate a commit fault.
if (baseRootParent.Equals("no base root"))
{
throw new CommitFaultException("Transaction history contains introduced version.");
}
// Go through each log entry and determine if there's a clash,
string rootLine = rootReader.ReadLine();
while (rootLine != null)
{
String mfile = rootLine.Substring(2);
// This represents a file modification,
bool unknownCommand = false;
if (rootLine.StartsWith("F"))
{
rootEvents.SetFileChange(mfile);
}
// This is a table modification,
else if (rootLine.StartsWith("T"))
{
char c = rootLine[1];
// If this is a table create or delete event,
if (c == 'C' || c == 'D')
{
rootEvents.SetTableCreateOrDelete(mfile);
}
// This is a table structural change,
else if (c == 'S')
{
rootEvents.SetTableStructuralChange(mfile);
}
// This is a table data change event,
else if (c == 'M')
{
DbTable table = rootTransaction.GetTable(mfile);
rootEvents.SetTableDataChange(mfile, table);
}
else
{
unknownCommand = true;
}
}
else
{
unknownCommand = true;
}
if (unknownCommand)
{
throw new ApplicationException("Unknown transaction command: " + rootLine);
}
// Read the next log entry,
rootLine = rootReader.ReadLine();
}
}
// Now we have a set of RootEvents objects that describe what
// happens in each previous root.
// Now replay the events in the proposal transaction in the latest
// transaction.
// A transaction representing the current state,
DataAddress currentRoot = connection.GetSnapshot();
ITransaction currentT = connection.CreateTransaction(currentRoot);
DbTransaction currentTransaction = new DbTransaction(null, currentRoot, currentT);
String entry = reader.ReadLine();
while (entry != null)
{
String mfile = entry.Substring(2);
// If it's a file entry, we need to check the file hasn't been
// changed in any way in any roots
if (entry.StartsWith("F"))
{
foreach (RootEvents events in rootEventSet)
{
events.CheckFileChange(mfile);
}
// All checks passed, so perform the operation
currentTransaction.ReplayFileLogEntry(entry, proposedTransaction);
}
// If it's a table entry,
else if (entry.StartsWith("T"))
{
// Check that a table with this name hasn't been created, deleted
// or modified,
foreach (RootEvents events in rootEventSet)
{
// This fails on any event on this table, except a data change
// (insert or delete)
events.CheckTableMetaChange(mfile);
}
// The type of operation,
char c = entry[1];
// Is it a table structural change?
if (c == 'S')
{
// A structural change can only happen if all the roots leave the
// table untouched,
foreach (RootEvents events in rootEventSet)
{
// This fails if it finds a delete event for this rowid
events.CheckTableDataChange(mfile);
}
}
// Is it a table modification command?
else if (c == 'M')
{
// This is a table modification, we need to check the rowid
// logs and look for possible clashes,
// The delete set from the proposed transaction,
DbTable proposedTable = proposedTransaction.GetTable(mfile);
SortedIndex deleteSet = proposedTable.Deletes;
IIndexCursor dsi = deleteSet.GetCursor();
while (dsi.MoveNext())
{
long rowid = dsi.Current;
foreach (RootEvents events in rootEventSet)
{
// This fails if it finds a delete event for this rowid
events.CheckTableDataDelete(mfile, rowid);
}
}
}
// Go through each root, if the data in the table was changed
// by any of the roots, we set 'has_data_changes' to true;
bool hasDataChanges = false;
foreach (RootEvents events in rootEventSet)
{
if (events.HasTableDataChanges(mfile))
{
hasDataChanges = true;
}
}
// Ok, checks passed, so reply all the data changes on the table
currentTransaction.ReplayTableLogEntry(entry, proposedTransaction, hasDataChanges);
}
else
{
throw new ApplicationException("Unknown transaction command: " + entry);
}
// Read the next log entry,
entry = reader.ReadLine();
}
// Refresh the transaction log
currentTransaction.RefreshTransactionLog();
// Flush and publish the change
DataAddress finalRoot = connection.CommitTransaction(currentT);
connection.Publish(finalRoot);
// Done.
return(finalRoot);
} catch (IOException e) {
throw new ApplicationException("IO Error: " + e.Message);
}
}
public ReverseCursor(IIndexCursor source)
{
this.source = source;
this.source.Position = source.Count;
}
internal DbRowCursor(DbTable table, long tableVersion, IIndexCursor cursor)
{
this.table = table;
this.tableVersion = tableVersion;
this.cursor = cursor;
}
public DefaultRowCursor(IIndexCursor<RowId> cursor)
{
this.cursor = cursor;
}