private void RestoreNotFinishedTransactions()
{
//TODO Trie settings from the table must be taken from schema (when they will differ)
//STORE FILE NAME of rollback not table name
try
{
byte[] btCommittedTablesNames = null;
List <string> committedTablesNames = new List <string>();
if (LTrie.Count(false) == 0) //All ok
{
LTrie.RemoveAll(true);
return;
}
string physicalPathToTheUserTable = String.Empty;
//Settigns and storage for Committed tables !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! MUST BE TAKEN FROM SCHEMA, FOR NOW DEFAULT
TrieSettings ltrSet = null;
IStorage storage = null;
DBriize.LianaTrie.LTrie ltrie = null;
foreach (var row in LTrie.IterateForward(true, false))
{
btCommittedTablesNames = row.GetFullValue(true);
committedTablesNames = System.Text.Encoding.UTF8.GetString(btCommittedTablesNames).DeserializeXml <List <string> >();
foreach (var fn in committedTablesNames)
{
//Trying to get path from the Schema, there is universal function for getting table physical TABLE FULL PATH /NAME
physicalPathToTheUserTable = Engine.DBriizeSchema.GetPhysicalPathToTheUserTable(fn);
//Returned path can be empty, if no more such table
if (physicalPathToTheUserTable == String.Empty)
{
continue;
}
//We don't restore in-memory tables
if (physicalPathToTheUserTable == "MEMORY")
{
continue;
}
//we open ltrie, and it automatically restores rollback
ltrSet = new TrieSettings(); //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! MUST BE TAKEN FROM SCHEMA, FOR NOW DEFAULT
//storage = new TrieDiskStorage(physicalPathToTheUserTable, ltrSet, Engine.Configuration);
storage = new StorageLayer(physicalPathToTheUserTable, ltrSet, Engine.Configuration);
ltrie = new LTrie(storage);
//closing trie, that Schema could open it again
ltrie.Dispose();
////Deleting rollback file for such table
//physicalPathToTheUserTable += ".rol";
//System.IO.File.Delete(physicalPathToTheUserTable);
}
committedTablesNames.Clear();
}
//If all ok, recreate file
LTrie.RemoveAll(true);
}
catch (OperationCanceledException ex)
{
throw ex;
}
//catch (System.Threading.ThreadAbortException ex)
//{
// //We don'T make DBisOperable = false;
// throw ex;
//}
catch (Exception)
{
//BRINGS TO DB NOT OPERATABLE
this.Engine.DBisOperable = false;
this.Engine.DBisOperableReason = "TransactionsCoordinator.RestoreNotFinishedTransaction";
//NOT CASCADE ADD EXCEPTION
throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.CLEAN_ROLLBACK_FILES_FOR_FINISHED_TRANSACTIONS_FAILED);
}
}
/// <summary>
/// Indexer self
/// </summary>
void Indexer()
{
int maximalIterations = 10; //Iterations then a breath
int currentItter = 0;
Dictionary <byte[], Dictionary <string, HashSet <uint> > > defTasks = new Dictionary <byte[], Dictionary <string, HashSet <uint> > >();
Dictionary <string, HashSet <uint> > defTask = null;
Dictionary <string, TextSearchHandler.ITS> itbls = new Dictionary <string, TextSearchHandler.ITS>();
while (true)
{
currentItter = 0;
defTasks.Clear();
itbls.Clear();
lock (lock_operation)
{
foreach (var row in LTrie.IterateForward(false).Take(maximalIterations))
{
currentItter++;
defTask = new Dictionary <string, HashSet <uint> >();
DBreeze.Utils.Biser.Decode_DICT_PROTO_STRING_UINTHASHSET(row.GetFullValue(true), defTask, Compression.eCompressionMethod.NoCompression);
defTasks.Add(row.Key, defTask);
foreach (var el in defTask)
{
if (!itbls.ContainsKey(el.Key))
{
itbls[el.Key] = new TextSearchHandler.ITS();
}
foreach (var el1 in el.Value)
{
itbls[el.Key].ChangedDocIds.Add((int)el1);
}
}
}
if (currentItter == 0)
{
inDeferredIndexer = 0; //going out
return;
}
}
//Indexing defTasks
using (var tran = this.DBreezeEngine.GetTransaction())
{
tran.tsh = new TextSearchHandler(tran);
tran.SynchronizeTables(itbls.Keys.ToList());
tran.tsh.DoIndexing(tran, itbls);
tran.Commit();
itbls.Clear();
}
//Removing indexed docs from LTrie
lock (lock_operation)
{
byte[] key = null;
foreach (var el in defTasks)
{
key = el.Key;
LTrie.Remove(ref key);
}
LTrie.Commit();
}
} //eo while
} //eof
