Beispiel #1
0
        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);
            }
        }
Beispiel #2
0
        /// <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