예제 #1
0
        /// <summary>
        /// Removes resource from database and
        /// </summary>
        public void Remove(string resourceName)
        {
            if (String.IsNullOrEmpty(resourceName))
            {
                return;
            }

            string rn = _urp + resourceName;

            byte[] btKey = DataTypesConvertor.ConvertKey <string>(rn);

            _sync.EnterWriteLock();
            try
            {
                _d.Remove(rn);
                LTrie.Remove(ref btKey);
                LTrie.Commit();
            }
            catch (Exception ex)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DBriize_RESOURCES_CONCERNING, "in Remove", ex);
            }
            finally
            {
                _sync.ExitWriteLock();
            }
        }
예제 #2
0
        /// <summary>
        /// Checks validity of the user table name
        /// </summary>
        /// <param name="tableName"></param>
        public static void UserTableNameIsOk(string tableName)
        {
            if (tableName == String.Empty)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TABLE_NAMES_TABLENAMECANTBEEMPTY);
            }

            for (int i = 0; i < tableName.Length; i++)
            {
                switch (tableName[i])
                {
                case '*':       //used as pattern mask
                case '#':       //used as pattern mask
                case '$':       //used as pattern mask
                case '@':       //used for system tables
                case '\\':      //reserved by DBriize
                case '^':       //reserved by DBriize
                case '~':       //reserved by DBriize
                case '´':       //reserved by DBriize
                    throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TABLE_NAMES_TABLENAMECANT_CONTAINRESERVEDSYMBOLS);
                }
            }

            return;
        }
예제 #3
0
        /// <summary>
        /// Converts key type to a byte[]
        /// </summary>
        /// <typeparam name="TData"></typeparam>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte[] ConvertKey <TData>(TData data)
        {
            if (data == null)
            {
                return(null);
            }

            Type td = typeof(TData);

            Func <object, byte[]> f = null;

            if (dck.TryGetValue(td, out f))
            {
                return(f(data));
            }

            if (td.GetTypeInfo().IsEnum)
            {
                var enumtype = Enum.GetUnderlyingType(td);
                if (dce.TryGetValue(enumtype, out f))
                {
                    return(f(data));
                }
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.UNSUPPORTED_DATATYPE, td.ToString(), null);
            }

            throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.UNSUPPORTED_DATATYPE, td.ToString(), null);
        }
예제 #4
0
        /// <summary>
        /// Standard and transactional rollback
        /// </summary>
        public void Rollback()
        {
            try
            {
                lock (lock_fs)
                {
                    //Clearing random buffer
                    if (_randBuf.Count() != 0)
                    {
                        usedBufferSize = 0;
                        _randBuf.Clear();
                    }

                    //Restoring Rollback records
                    byte[] btWork = null;

                    if (_rollbackCache.Count() > 0)
                    {
                        foreach (var rb in _rollbackCache)
                        {
                            btWork = new byte[rb.Value.l];

                            btWork = _fsRollback.Read((int)rb.Value.o, btWork.Length);

                            //_fsRollback.Position = rb.Value.o;
                            //_fsRollback.Read(btWork, 0, btWork.Length);

                            _fsData.Write_ByOffset((int)rb.Key, btWork);
                            //_fsData.Position = rb.Key;
                            //_fsData.Write(btWork, 0, btWork.Length);
                        }

                        //NET_Flush(_fsData);

                        //Restoring rhp
                        eofRollback = 0;
                        btWork      = eofRollback.To_8_bytes_array_BigEndian();
                        _fsRollbackHelper.Write_ByOffset(0, btWork);
                        //_fsRollbackHelper.Position = 0;
                        //_fsRollbackHelper.Write(eofRollback.To_8_bytes_array_BigEndian(), 0, 8);

                        //NET_Flush(_fsRollbackHelper);

                        //Clearing rollbackCache
                        _rollbackCache.Clear();
                    }

                    //we dont move eofData, space can be re-used up to next restart (may be root can have this info in next protocols)
                    //eofData = this._fsData.Length;
                }
            }
            catch (Exception ex)
            {
                IsOperable = false;
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.RESTORE_ROLLBACK_DATA_FAILED, this._fileName, ex);
            }
        }
예제 #5
0
        /// <summary>
        /// Throws exception if smth. happened.
        /// Returns either original table name or cutted if * is found
        /// </summary>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public static string UserTablePatternIsOk(string tableName)
        {
            //RULES:
            // tableName should not be empty
            // * means all following characters -> .+   <- what means must 1 or more any characters
            // $ means all following characters without slash, after $ should be no more characters
            // # means must be 1 or more characters, except slash, and followed by slash and another symbol
            // after slash must come something else
            // all what is after * will be cutted (for patterns storage)

            //Cars# - NOT acceptable (no trailing slash)  - may be add slash automatic?
            //Cars#/ - NOT acceptable (no symbol after slash)
            //Cars#/Items# - NOT acceptable (no trailing slash)
            //Cars#/I - acceptable
            //Cars#/* - acceptable
            //Cars*/Items -> converts into Cars* - and acceptable
            //Cars* - acceptable
            //Cars#/Items123 - acceptable
            //Cars#/Items#/ - acceptable
            //Cars#/Items* - acceptable


            if (tableName == String.Empty)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TABLE_PATTERN_CANTBEEMPTY);
            }

            for (int i = 0; i < tableName.Length; i++)
            {
                switch (tableName[i])
                {
                case '*':
                    //Substring till * and return
                    return(tableName.Substring(0, i + 1));

                case '$':
                    //Substring till $ and return
                    return(tableName.Substring(0, i + 1));

                case '#':

                    if ((i + 2) > (tableName.Length - 1))
                    {
                        throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TABLE_PATTERN_SYMBOLS_AFTER_SHARP);
                    }

                    if (tableName[i + 1] != '/')
                    {
                        throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TABLE_PATTERN_SYMBOLS_AFTER_SHARP);
                    }

                    break;
                }
            }

            return(tableName);
        }
예제 #6
0
파일: RISR.cs 프로젝트: joemphilips/DBriize
        private void InitFiles()
        {
            //Creates filestreams and rollbacks, restores rollback to the initial file, if necessary

            try
            {
                RIC.OpenRemoteTable(this._fileName);

                //this._fsData = new FileStream(this._fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough);
                //this._fsRollback = new FileStream(this._fileName + ".rol", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough);
                //this._fsRollbackHelper = new FileStream(this._fileName + ".rhp", FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _fileStreamBufferSize, FileOptions.WriteThrough);

                //!!!!We dont have this value in root yet, could have and economize tail of the file in case if rollback occured

                //if (this._fsData.Length == 0)
                if (RIC.DataFileLength == 0)
                {
                    //Writing initial root data

                    RIC.DataFilePosition = 0;
                    RIC.DataFileWrite(new byte[this._trieSettings.ROOT_SIZE], 0, this._trieSettings.ROOT_SIZE, false);
                    //_fsData.Position = 0;
                    //_fsData.Write(new byte[this._trieSettings.ROOT_SIZE], 0, this._trieSettings.ROOT_SIZE);


                    if (_backupIsActive)
                    {
                        this._configuration.Backup.WriteBackupElement(ulFileName, 0, 0, new byte[this._trieSettings.ROOT_SIZE]);
                    }

                    //no flush here
                }

                eofData = RIC.DataFileLength;
                //eofData = this._fsData.Length;

                //Check is .rhp is empty add 0 pointer
                //if (this._fsRollbackHelper.Length == 0)
                if (RIC.RollbackHelperFileLength == 0)
                {
                    //no sense to write here
                }
                else
                {
                    InitRollback();
                }


                _storageFixTime = DateTime.UtcNow;
            }
            catch (Exception ex)
            {
                IsOperable = false;
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DB_IS_NOT_OPERABLE, "RISR INIT FAILED: " + this._fileName, ex);
            }
        }
예제 #7
0
        /// <summary>
        /// Returns transaction object.
        /// </summary>
        /// <param name="tablesLockType">
        /// <para>SHARED: threads can use listed tables in parallel. Must be used together with tran.SynchronizeTables command, if necessary.</para>
        /// <para>EXCLUSIVE: if other threads use listed tables for reading or writing, current thread will be in a waiting queue.</para>
        /// </param>
        /// <param name="tables"></param>
        /// <returns>Returns transaction object</returns>
        public Transaction GetTransaction(eTransactionTablesLockTypes tablesLockType, params string[] tables)
        {
            if (!DBisOperable)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DB_IS_NOT_OPERABLE, DBisOperableReason, new Exception());
            }

            //User receives new transaction from the engine
            return(this._transactionsCoordinator.GetTransaction(1, tablesLockType, tables));
        }
예제 #8
0
        /// <summary>
        /// Deletes user table
        /// </summary>
        /// <param name="userTableName"></param>
        public void DeleteTable(string userTableName)
        {
            string tableName = GetUserTableNameAsString(userTableName);

            this.cachedTableNames.Remove(tableName);

            //Blocking Schema
            _sync_openTablesHolder.EnterWriteLock();
            try
            {
                if (_openTablesHolder.ContainsKey(tableName))
                {
                    //Someone can use this table
                    //We dispose table, what will cause disposing DBstorage and RollbackStorage
                    //In this moment parallel reading table threads inside of Iterations, can get Exceptions - What is acceptable for now.
                    _openTablesHolder[tableName].Dispose();


                    _openTablesHolder[tableName] = null;

                    //Deleting table from the holder
                    _openTablesHolder.Remove(tableName);
                }

                //Trying to get full file name, via globilzed function which will also support mapping outside the DB main directory
                string physicalDbFileName = GetPhysicalPathToTheUserTable(userTableName);

                if (physicalDbFileName == String.Empty)
                {
                    return; //fake
                }
                //Removing record from the schema

                byte[] btTableName = GetUserTableNameAsByte(userTableName);

                //ulong cc = LTrie.Count();
                LTrie.Remove(ref btTableName);
                LTrie.Commit();
                //cc = LTrie.Count();

                //Deleting file physically
                if (physicalDbFileName != "MEMORY")
                {
                    DeleteAllReleatedTableFiles(physicalDbFileName);
                }
            }
            catch (System.Exception ex)
            {
                DBriizeException.Throw(DBriizeException.eDBriizeExceptions.SCHEME_TABLE_DELETE_FAILED, userTableName, ex);
            }
            finally
            {
                _sync_openTablesHolder.ExitWriteLock();
            }
        }
        /// <summary>
        /// Can return NULL (if DbIsNotOperatable)
        /// </summary>
        /// <param name="tableName"></param>
        /// <param name="transactionThreadId"></param>
        /// <returns></returns>
        public LTrie GetTable_WRITE(string tableName, int transactionThreadId)
        {
            if (!this._engine.DBisOperable)
            {
                return(null);
            }

            TransactionUnit transactionUnit = this.GetTransactionUnit(transactionThreadId);

            if (transactionUnit != null)
            {
                if (Environment.CurrentManagedThreadId != transactionThreadId)
                {
                    this.UnregisterTransaction(transactionThreadId);

                    throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TRANSACTION_CANBEUSED_FROM_ONE_THREAD);
                }


                //We must put Get_Table_Write through the same bottleneck as RegisterWriteTablesForTransaction
                this.RegisterWriteTablesForTransaction(transactionThreadId, new List <string> {
                    tableName
                }, false);
                //it will wait here till table for writing, reserved by other thread is released

                LTrie tbl = null;

                try
                {
                    tbl = this._engine.DBriizeSchema.GetTable(tableName);

                    //Adding table to transaction unit with the ITransactable interface
                    transactionUnit.AddTransactionWriteTable(tableName, tbl);    //added together with ITransactable

                    //TODO  -   THIS TABLE LTrie must be Interfaced
                    //Telling to the table that transactionThreadId Thread will modify it
                    tbl.ModificationThreadId(transactionThreadId);
                }
                catch (Exception ex)
                {
                    //Exception must come from Schema, by in-ability to get the table
                    this.UnregisterTransaction(transactionThreadId);

                    //CIRCULAR PARTLY
                    throw ex;
                }

                return(tbl);
            }
            else
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TRANSACTION_DOESNT_EXIST);
            }
        }
예제 #10
0
 /// <summary>
 /// Serializes object to JSON from Microsoft
 /// </summary>
 /// <param name="objectForSerialization"></param>
 /// <returns></returns>
 public static string SerializeCustom(this object objectForSerialization)
 {
     try
     {
         return(Serializator(objectForSerialization));
     }
     catch (Exception ex)
     {
         throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.CUSTOM_SERIALIZATION_ERROR, ex);
     }
 }
예제 #11
0
 /// <summary>
 /// Deserializes object from Microsoft JSON string
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="str"></param>
 /// <returns></returns>
 public static T DeserializeCustom <T>(this string str)
 {
     try
     {
         return((T)Deserializator(str, typeof(T)));
     }
     catch (Exception ex)
     {
         throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.CUSTOM_DESERIALIZATION_ERROR, ex);
     }
 }
예제 #12
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="transactionType">0 = standard transaction, 1 - locked transaction</param>
        /// <param name="lockType"></param>
        /// <param name="tables"></param>
        /// <returns></returns>
        public Transaction GetTransaction(int transactionType, eTransactionTablesLockTypes lockType, params string[] tables)
        {
            //this check is done on upper level
            //if (!this.DbIsOperatable)
            //    return null;

            //Transaction must have 2 classes one class is for the user, with appropriate methods, second for technical purposes TransactionDetails, where we store different transaction information
            //both classes must be bound into one class TransactionUnit

            TransactionUnit transactionUnit = new TransactionUnit(transactionType, this, lockType, tables);


            //Checking if the same transaction already exists in the list of Transactions.
            //It could happen in case of abnormal termination of parallel thread, without disposing of the transaction.
            //So we delete pending transaction first, then create new one.
            bool reRun = false;

            _sync_transactions.EnterReadLock();
            try
            {
                if (this._transactions.ContainsKey(transactionUnit.TransactionThreadId))
                {
                    reRun = true;
                }
            }
            finally
            {
                _sync_transactions.ExitReadLock();
            }

            if (reRun)
            {
                UnregisterTransaction(transactionUnit.TransactionThreadId);
                return(GetTransaction(transactionType, lockType, tables));
            }

            //Adding transaction to the list
            _sync_transactions.EnterWriteLock();
            try
            {
                this._transactions.Add(transactionUnit.TransactionThreadId, transactionUnit);
            }
            catch (System.Exception ex)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TRANSACTION_GETTING_TRANSACTION_FAILED, ex);
            }
            finally
            {
                _sync_transactions.ExitWriteLock();
            }

            return(transactionUnit.Transaction);
        }
예제 #13
0
        /// <summary>
        /// Returns physical path to the table file, if table doesn't exists in the Scheme returns String.Empty
        /// </summary>
        /// <param name="userTableName"></param>
        /// <returns></returns>
        public string GetTablePathFromTableName(string userTableName)
        {
            //For user usage

            _sync_openTablesHolder.EnterReadLock();
            try
            {
                byte[] btTableName = GetUserTableNameAsByte(userTableName);

                LTrieRow row = LTrie.GetKey(btTableName, true, false);

                if (!row.Exists)
                {
                    return(String.Empty);
                }

                byte[] fullValue = row.GetFullValue(true);
                //Can be parsed different. First protocol version is 1
                ushort schemeProtocol = fullValue.Substring(0, 2).To_UInt16_BigEndian();
                ulong  fileName       = 0;
                switch (schemeProtocol)
                {
                case 1:
                    fileName = fullValue.Substring(2, 8).To_UInt64_BigEndian();
                    break;

                default:
                    throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.SCHEME_FILE_PROTOCOL_IS_UNKNOWN);
                }

                string alternativeTableLocation = String.Empty;

                if (CheckAlternativeTableLocationsIntersections(userTableName, out alternativeTableLocation))
                {
                    if (alternativeTableLocation == String.Empty)
                    {
                        return("MEMORY");
                    }
                    else
                    {
                        return(Path.Combine(alternativeTableLocation, fileName.ToString()));
                    }
                }
                else
                {
                    return(Path.Combine(Engine.MainFolder, fileName.ToString()));
                }
            }
            finally
            {
                _sync_openTablesHolder.ExitReadLock();
            }
        }
예제 #14
0
        /// <summary>
        /// CONVERTING FROM byte[] to the generic type
        /// </summary>
        /// <typeparam name="TData"></typeparam>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static TData ConvertBack <TData>(byte[] dt)
        {
            if (dt == null)
            {
                return(default(TData));
            }

            Type td = typeof(TData);

            Func <byte[], object> f = null;

            if (dcb.TryGetValue(td, out f))
            {
                return((TData)f(dt));
            }

            if (td.Name.Equals("DbMJSON`1") || td.Name.Equals("DbCustomSerializer`1") || td.Name.Equals("DbXML`1"))
            {
                object o = Activator.CreateInstance(td);
                ((IDBConvertable)o).SetBytes(dt);
                return((TData)o);
            }

            if (td == TYPE_OBJECT)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.UNSUPPORTED_DATATYPE, td.ToString(), null);
            }


            if (td.GetTypeInfo().IsEnum)
            {
                var enumtype = Enum.GetUnderlyingType(td);
                if (dcbe.TryGetValue(enumtype, out f))
                {
                    return((TData)f(dt));
                }

                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.UNSUPPORTED_DATATYPE, td.ToString(), null);
            }

            if (CustomSerializator.ByteArrayDeSerializator != null)
            {
                return((TData)CustomSerializator.ByteArrayDeSerializator(dt, td));
            }

            throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.UNSUPPORTED_DATATYPE, td.ToString(), null);
        }
예제 #15
0
        /// <summary>
        /// InitDb
        /// </summary>
        private void InitDb()
        {
            //trying to check and create folder


            try
            {
                lock (lock_initDb)
                {
                    //Init type converter
                    DataTypes.DataTypesConvertor.InitDict();

                    if (Configuration.Storage == DBriizeConfiguration.eStorage.DISK)
                    {
                        DirectoryInfo di = new DirectoryInfo(MainFolder);

                        if (!di.Exists)
                        {
                            di.Create();
                        }
                    }

                    //trying to open schema file
                    DBriizeSchema = new Scheme(this);

                    //Initializing Transactions Coordinator
                    _transactionsCoordinator = new TransactionsCoordinator(this);

                    //Initializing transactions Journal, may be later move journal into transactionsCoordinator
                    //We must create journal after Schema, for getting path to rollback files
                    _transactionsJournal = new TransactionsJournal(this);

                    //Initializes transaction locker, who can help block tables of writing and reading threads
                    _transactionTablesLocker = new TransactionTablesLocker();

                    //Initializing
                    DeferredIndexer = new TextDeferredIndexer(this);
                }
            }
            catch (Exception ex)
            {
                DBisOperable       = false;
                DBisOperableReason = "InitDb";
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.CREATE_DB_FOLDER_FAILED, ex);
            }
        }
예제 #16
0
        internal static byte[] ConvertValue(object data, Type td)
        {
            if (data == null)
            {
                return(null);
            }

            //Type td = typeof(TData);

            Func <object, byte[]> f = null;

            if (dcv.TryGetValue(td, out f))
            {
                return(f(data));
            }

            if (td.Name == "DbMJSON`1" || td.Name == "DbCustomSerializer`1" || td.Name == "DbXML`1")
            {
                return(((IDBConvertable)((object)data)).GetBytes());
            }

            if (td == TYPE_OBJECT)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.UNSUPPORTED_DATATYPE, td.ToString(), null);
            }

            if (td.GetTypeInfo().IsEnum)
            {
                var enumtype = Enum.GetUnderlyingType(td);
                if (dce.TryGetValue(enumtype, out f))
                {
                    return(f(data));
                }
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.UNSUPPORTED_DATATYPE, td.ToString(), null);
            }

            //Trying byte serialization for unknown object, in case if byte serializer is set
            if (CustomSerializator.ByteArraySerializator != null)
            {
                return(CustomSerializator.ByteArraySerializator(data));
            }

            throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.UNSUPPORTED_DATATYPE, td.ToString(), null);
        }
예제 #17
0
        /// <summary>
        /// Can return NULL if table doesn't exist
        /// Can return NULL (if DbIsNotOperatable)
        ///
        /// Differs from GetTable_Write:
        /// 1. table is not registered for Write;
        /// 2. Table is not created, if doesn't exist.
        /// </summary>
        /// <param name="tableName"></param>
        /// <param name="transactionThreadId"></param>
        /// <param name="ignoreThreadIdCheck"></param>
        /// <returns></returns>
        public LTrie GetTable_READ(string tableName, int transactionThreadId, bool ignoreThreadIdCheck = false)
        {
            if (!this._engine.DBisOperable)
            {
                return(null);
            }

            TransactionUnit transactionUnit = this.GetTransactionUnit(transactionThreadId);

            if (transactionUnit != null)
            {
                if (!ignoreThreadIdCheck && Environment.CurrentManagedThreadId != transactionThreadId)
                {
                    this.UnregisterTransaction(transactionThreadId);
                    throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TRANSACTION_CANBEUSED_FROM_ONE_THREAD);
                }

                LTrie tbl = null;

                try
                {
                    if (!this._engine.DBriizeSchema.IfUserTableExists(tableName))
                    {
                        return(null);
                    }

                    tbl = this._engine.DBriizeSchema.GetTable(tableName);
                }
                catch (Exception ex)
                {
                    //Exception must come from Schema, by in-ability to get the table
                    this.UnregisterTransaction(transactionThreadId);

                    //CIRCULAR PARTLY
                    throw ex;
                }

                return(tbl);
            }
            else
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TRANSACTION_DOESNT_EXIST);
            }
        }
예제 #18
0
        public void RollBack()
        {
            try
            {
                this.Tree.Cache.RollBack();

                //Important, Better to re-read all generation nodes for safety reasons, de bene esse
                this._generationMap.Clear();

                //And re-Read RootNode
                ReadRootNode();
            }
            catch (Exception ex)
            {
                //HERE DB MUST BECOMES NOT-OPERABLE !!!!!!!!!!!!!!!!!!!!!!!!!

                //PARTIALLY CASCADE  this.Tree.Cache.RollBack(); has wrap, others not
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.ROLLBACK_FAILED, this.Tree.TableName, ex);
            }
        }
예제 #19
0
        public void TransactionalCommit()
        {
            try
            {
                ////rollbak will be done on the level of the tree
                this.Save_GM_nodes_Starting_From(0);

                byte[] oldRoot = me;

                //Gettign new root for save
                me = this.SerializeRootNode();

                //Synchronized inside
                //this.Tree.Cache.TransactionalCommit(this.EmptyPointer, ref me, ref oldRoot);

                this.Tree.Cache.TransactionalCommit(ref me, ref oldRoot);
            }
            catch (Exception ex)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TRANSACTIONAL_COMMIT_FAILED, this.Tree.TableName, ex);
            }
        }
예제 #20
0
        private void InitBackupFolder()
        {
            try
            {
                DirectoryInfo di = new DirectoryInfo(this._backupFolderName);

                if (!di.Exists)
                {
                    di.Create();
                }


                //bmFs = new FileStream(Path.Combine(this._backupFolderName, "DBriizeBM.mg1"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None, _bufferSize);

                IsActive = true;
            }
            catch (Exception ex)
            {
                IsActive = false;
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.BACKUP_FOLDER_CREATE_FAILED, ex);
            }
        }
예제 #21
0
        /// <summary>
        /// Removes resources from database and In-Memory dictionary
        /// </summary>
        public void Remove(IList <string> resourcesNames)
        {
            if (resourcesNames == null || resourcesNames.Count == 0)
            {
                return;
            }

            byte[] btKey;
            string rn = String.Empty;

            _sync.EnterWriteLock();
            try
            {
                foreach (var rs in resourcesNames)
                {
                    if (String.IsNullOrEmpty(rs))
                    {
                        continue;
                    }

                    rn = _urp + rs;
                    _d.Remove(rn);

                    btKey = DataTypesConvertor.ConvertKey <string>(rn);
                    LTrie.Remove(ref btKey);
                }

                LTrie.Commit();
            }
            catch (Exception ex)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DBriize_RESOURCES_CONCERNING, "in Remove batch", ex);
            }
            finally
            {
                _sync.ExitWriteLock();
            }
        }
예제 #22
0
        private void InitFiles()
        {
            //Creates filestreams and rollbacks, restores rollback to the initial file, if necessary

            try
            {
                this._fsData           = new MemoryStorage(1024 * 16, 1024 * 500, MemoryStorage.eMemoryExpandStartegy.FIXED_LENGTH_INCREASE);
                this._fsRollback       = new MemoryStorage(1024 * 16, 1024 * 128, MemoryStorage.eMemoryExpandStartegy.FIXED_LENGTH_INCREASE);
                this._fsRollbackHelper = new MemoryStorage(8, 10, MemoryStorage.eMemoryExpandStartegy.FIXED_LENGTH_INCREASE);

                //Writing root
                this._fsData.Write_ToTheEnd(new byte[64]);

                eofData = this._fsData.EOF;

                _storageFixTime = DateTime.UtcNow;
            }
            catch (Exception ex)
            {
                IsOperable = false;
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DB_IS_NOT_OPERABLE, "MSR INIT FAILED: " + this._fileName, ex);
            }
        }
예제 #23
0
        public void Commit()
        {
            try
            {
                this.Save_GM_nodes_Starting_From(0);

                byte[] oldRoot = me;

                me = this.SerializeRootNode();

                //Synchronized inside
                //DBriize.Diagnostic.SpeedStatistic.StartCounter("Commit");
                //this.Tree.Cache.Commit(this.EmptyPointer, ref me, ref oldRoot);
                this.Tree.Cache.Commit(ref me, ref oldRoot);
                //DBriize.Diagnostic.SpeedStatistic.StopCounter("Commit");
            }
            catch (Exception ex)
            {
                ////rollbak will be done on the level of the tree

                ////////////////////////////////////////
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.COMMIT_FAILED, this.Tree.TableName, ex);
            }
        }
예제 #24
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);
            }
        }
예제 #25
0
        /// <summary>
        /// Gets resource from memory or database (if not yet loaded)
        /// Value instance, when byte[], must stay immutable, please use DBriize.Utils.CloneArray
        /// </summary>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="resourceName"></param>
        /// <param name="resourceSettings">resource extra behaviour</param>
        /// <returns></returns>
        public TValue Select <TValue>(string resourceName, Settings resourceSettings = null)
        {
            if (String.IsNullOrEmpty(resourceName))
            {
                return(default(TValue));
            }
            if (resourceSettings == null)
            {
                resourceSettings = _defaultSetting;
            }

            byte[] val = null;
            string rn  = _urp + resourceName;

            _sync.EnterUpgradeableReadLock();
            try
            {
                if (!_d.TryGetValue(rn, out val))
                {
                    //Value is not found
                    _sync.EnterWriteLock();
                    try
                    {
                        //At this moment value appeared
                        if (_d.TryGetValue(rn, out val))
                        {
                            return(val == null ? default(TValue) : DataTypesConvertor.ConvertBack <TValue>(val));
                        }

                        //trying to get from database
                        byte[] btKey = DataTypesConvertor.ConvertKey <string>(rn);
                        var    row   = LTrie.GetKey(btKey, false, false);
                        if (row.Exists)
                        {
                            val = row.GetFullValue(false);
                            if (val == null)
                            {
                                if (resourceSettings.HoldInMemory)
                                {
                                    _d[rn] = null;
                                }

                                return(default(TValue));
                            }
                            else
                            {
                                if (resourceSettings.HoldInMemory)
                                {
                                    _d[rn] = val;
                                }

                                return(DataTypesConvertor.ConvertBack <TValue>(val));
                            }
                        }
                        else
                        {
                            if (resourceSettings.HoldInMemory)
                            {
                                _d[rn] = null;
                            }

                            return(default(TValue));
                        }
                    }
                    catch (Exception ex)
                    {
                        throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DBriize_RESOURCES_CONCERNING, "in Select 1", ex);
                    }
                    finally
                    {
                        _sync.ExitWriteLock();
                    }
                }
                else
                {
                    return(val == null ? default(TValue) : DataTypesConvertor.ConvertBack <TValue>(val));
                }
            }
            catch (System.Exception ex)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DBriize_RESOURCES_CONCERNING, "in Select 2", ex);
            }
            finally
            {
                _sync.ExitUpgradeableReadLock();
            }
        }
예제 #26
0
        /// <summary>
        /// Gets resources of the same type as a batch from memory or database (if not yet loaded).
        /// Value instance, when byte[], must stay immutable, please use DBriize.Utils.CloneArray
        /// </summary>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="resourcesNames"></param>
        /// <param name="resourceSettings">resource extra behaviour</param>
        /// <returns></returns>
        public IDictionary <string, TValue> Select <TValue>(IList <string> resourcesNames, Settings resourceSettings = null)
        {
            Dictionary <string, TValue> ret = new Dictionary <string, TValue>();

            if (resourcesNames == null || resourcesNames.Count < 1)
            {
                return(ret);
            }
            if (resourceSettings == null)
            {
                resourceSettings = _defaultSetting;
            }

            byte[] val = null;
            string rn  = String.Empty;

            //bool ba = typeof(TValue) == typeof(byte[]);

            _sync.EnterUpgradeableReadLock();
            try
            {
                foreach (var rsn in resourcesNames.OrderBy(r => r))
                {
                    if (String.IsNullOrEmpty(rsn))
                    {
                        continue;
                    }
                    rn = _urp + rsn;

                    if (!_d.TryGetValue(rn, out val))
                    {
                        //Value is not found
                        _sync.EnterWriteLock();
                        try
                        {
                            //At this moment value appeared
                            if (_d.TryGetValue(rn, out val))
                            {
                                if (val != null)
                                {
                                    ret[rsn] = DataTypesConvertor.ConvertBack <TValue>(val);
                                }
                                else
                                {
                                    ret[rsn] = default(TValue);
                                }

                                continue;
                            }

                            //trying to get from database
                            byte[] btKey = DataTypesConvertor.ConvertKey <string>(rn);
                            var    row   = LTrie.GetKey(btKey, false, false);
                            if (row.Exists)
                            {
                                val = row.GetFullValue(false);
                                if (val == null)
                                {
                                    if (resourceSettings.HoldInMemory)
                                    {
                                        _d[rn] = null;
                                    }

                                    ret[rsn] = default(TValue);
                                }
                                else
                                {
                                    if (resourceSettings.HoldInMemory)
                                    {
                                        _d[rn] = val;
                                    }
                                    ret[rsn] = DataTypesConvertor.ConvertBack <TValue>(val);
                                }
                            }
                            else
                            {
                                if (resourceSettings.HoldInMemory)
                                {
                                    _d[rn] = null;
                                }

                                ret[rsn] = default(TValue);
                            }
                        }
                        catch (Exception ex)
                        {
                            throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DBriize_RESOURCES_CONCERNING, "in Select 1", ex);
                        }
                        finally
                        {
                            _sync.ExitWriteLock();
                        }
                    }
                    else
                    {
                        if (val == null)
                        {
                            ret[rsn] = default(TValue);
                        }
                        else
                        {
                            ret[rsn] = DataTypesConvertor.ConvertBack <TValue>(val);
                        }
                    }
                }//eo foreach
            }
            catch (System.Exception ex)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DBriize_RESOURCES_CONCERNING, "in Select 2", ex);
            }
            finally
            {
                _sync.ExitUpgradeableReadLock();
            }

            return(ret);
        }
예제 #27
0
        /// <summary>
        /// Batch insert of resources where value is a byte[]
        /// </summary>
        /// <param name="resources"></param>
        /// <param name="resourceSettings">resource extra behaviour</param>
        public void Insert(IDictionary <string, byte[]> resources, Settings resourceSettings = null)
        {
            if (resources == null || resources.Count < 1)
            {
                return;
            }

            if (resourceSettings == null)
            {
                resourceSettings = _defaultSetting;
            }

            byte[] btKey   = null;
            byte[] btExVal = null;
            string rn      = String.Empty;

            _sync.EnterWriteLock();
            try
            {
                bool cov = LTrie.OverWriteIsAllowed;
                if (resourceSettings.HoldOnDisk && resourceSettings.FastUpdates)
                {
                    LTrie.OverWriteIsAllowed = false;
                }

                foreach (var rs in resources.OrderBy(r => r.Key))
                {
                    if (String.IsNullOrEmpty(rs.Key))
                    {
                        continue;
                    }

                    rn = _urp + rs.Key;

                    //------- Verification, to prevent storing of the identical value
                    if (resourceSettings.InsertWithVerification)
                    {
                        if (_d.TryGetValue(rn, out btExVal))
                        {
                            if (btExVal._ByteArrayEquals(rs.Value))
                            {
                                continue;
                            }
                        }
                        else
                        {
                            //Grabbing from disk
                            if (resourceSettings.HoldOnDisk)
                            {
                                var row = LTrie.GetKey(btKey, false, false);
                                if (row.Exists)
                                {
                                    btExVal = row.GetFullValue(false);
                                    if (btExVal._ByteArrayEquals(rs.Value))
                                    {
                                        if (resourceSettings.HoldInMemory)
                                        {
                                            _d[rn] = rs.Value;
                                        }

                                        continue;
                                    }
                                }
                            }
                        }
                    }
                    //-------

                    if (resourceSettings.HoldInMemory)
                    {
                        _d[rn] = rs.Value;
                    }

                    if (resourceSettings.HoldOnDisk)
                    {
                        btKey = DataTypesConvertor.ConvertKey <string>(rn);
                        LTrie.Add(btKey, rs.Value);
                    }
                }

                if (resourceSettings.HoldOnDisk)
                {
                    if (resourceSettings.FastUpdates)
                    {
                        LTrie.OverWriteIsAllowed = cov;
                    }

                    LTrie.Commit();
                }
            }
            catch (Exception ex)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DBriize_RESOURCES_CONCERNING, "in Insert batch", ex);
            }
            finally
            {
                _sync.ExitWriteLock();
            }
        }
예제 #28
0
        /// <summary>
        /// Insert resource
        /// </summary>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="resourceName"></param>
        /// <param name="resourceObject"></param>
        /// <param name="resourceSettings">resource extra behaviour</param>
        public void Insert <TValue>(string resourceName, TValue resourceObject, Settings resourceSettings = null)
        {
            if (String.IsNullOrEmpty(resourceName))
            {
                return;
            }

            if (resourceSettings == null)
            {
                resourceSettings = _defaultSetting;
            }

            string rn = _urp + resourceName;

            byte[] btKey   = DataTypesConvertor.ConvertKey <string>(rn);
            byte[] btValue = DataTypesConvertor.ConvertValue <TValue>(resourceObject);

            _sync.EnterWriteLock();
            try
            {
                //------- Verification, to prevent storing of the identical value
                if (resourceSettings.InsertWithVerification)
                {
                    byte[] btExVal = null;
                    if (_d.TryGetValue(rn, out btExVal))
                    {
                        if (btExVal._ByteArrayEquals(btValue))
                        {
                            return;
                        }
                    }
                    else
                    {
                        //Grabbing from disk
                        if (resourceSettings.HoldOnDisk)
                        {
                            var row = LTrie.GetKey(btKey, false, false);
                            if (row.Exists)
                            {
                                btExVal = row.GetFullValue(false);
                                if (btExVal._ByteArrayEquals(btValue))
                                {
                                    if (resourceSettings.HoldInMemory)
                                    {
                                        _d[rn] = btValue;
                                    }

                                    return;
                                }
                            }
                        }
                    }
                }
                //-------


                if (resourceSettings.HoldOnDisk)
                {
                    bool cov = LTrie.OverWriteIsAllowed;
                    if (resourceSettings.FastUpdates)
                    {
                        LTrie.OverWriteIsAllowed = false;
                    }

                    LTrie.Add(btKey, btValue);
                    LTrie.Commit();

                    if (resourceSettings.FastUpdates)
                    {
                        LTrie.OverWriteIsAllowed = cov;
                    }
                }

                if (resourceSettings.HoldInMemory)
                {
                    _d[rn] = btValue;
                }
            }
            catch (Exception ex)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DBriize_RESOURCES_CONCERNING, "in Insert", ex);
            }
            finally
            {
                _sync.ExitWriteLock();
            }


            #region "remark"
            //            if (holdInMemory)
            //            {
            //                _sync.EnterWriteLock();
            //                try
            //                {
            //                    _d[resourceName] = btValue;
            //                }
            //                catch (Exception ex)
            //                {
            //                    throw ex;
            //                }
            //                finally
            //                {
            //                    _sync.ExitWriteLock();
            //                }
            //            }

            //            Action a = () =>
            //            {

            //                _sync.EnterWriteLock();
            //                try
            //                {
            //                    LTrie.Add(btKey, btValue);
            //                    LTrie.Commit();
            //                }
            //                catch (Exception ex)
            //                {
            //                    throw ex;
            //                }
            //                finally
            //                {
            //                    _sync.ExitWriteLock();
            //                }
            //            };

            //#if NET35 || NETr40   //The same must be use for .NET 4.0

            //            new System.Threading.Thread(new System.Threading.ThreadStart(() =>
            //            {
            //                a();
            //            })).Start();
            //#else
            //            System.Threading.Tasks.Task.Run(() => {
            //                a();
            //            });
            //#endif
            #endregion
        }
예제 #29
0
        public void Commit(int transactionThreadId)
        {
            if (!this._engine.DBisOperable)
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.DB_IS_NOT_OPERABLE, this._engine.DBisOperableReason, new Exception());
            }

            TransactionUnit transactionUnit = this.GetTransactionUnit(transactionThreadId);

            if (transactionUnit != null)
            {
                List <ITransactable> tablesForTransaction = transactionUnit.GetTransactionWriteTables();

                if (tablesForTransaction.Count() == 0)
                {
                    //DO NOTHING
                }
                else if (tablesForTransaction.Count() == 1)
                {
                    try
                    {
                        tablesForTransaction[0].SingleCommit();
                    }
                    catch (OperationCanceledException ex)
                    {
                        throw ex;
                    }
                    //catch (System.Threading.ThreadAbortException ex)
                    // {
                    //     //We don'T make DBisOperable = false;
                    //     throw ex;
                    // }
                    catch (TableNotOperableException ex1)
                    {
                        this._engine.DBisOperable       = false;
                        this._engine.DBisOperableReason = "TransactionsCoordinator.Commit tablesForTransaction.Count = 1";
                        //CASCADE, WHICH MUST BRING TO DB is not opearatbale state
                        throw ex1;
                    }
                    catch (System.Exception ex)
                    {
                        //Rollback was ok, so we just return mistake, why commit failed
                        //CASCADE
                        throw ex;
                    }
                }
                else
                {
                    //Gettign new TransactionJournalId
                    ulong tranNumber = this._engine._transactionsJournal.GetTransactionNumber();

                    foreach (var tt in tablesForTransaction)
                    {
                        try
                        {
                            //Adding table
                            this._engine._transactionsJournal.AddTableForTransaction(tranNumber, tt);
                            tt.ITRCommit();
                        }
                        catch (Exception ex)
                        {
                            //SMTH HAPPENED INSIDE OF COMMIT Trying to rollBack tables
                            try
                            {
                                foreach (var tt1 in tablesForTransaction)
                                {
                                    tt1.ITRRollBack();
                                }

                                this._engine._transactionsJournal.RemoveTransactionFromDictionary(tranNumber);
                            }
                            catch (OperationCanceledException ex1)
                            {
                                throw ex1;
                            }
                            //catch (System.Threading.ThreadAbortException ex1)
                            // {
                            //     //We don'T make DBisOperable = false;
                            //     throw ex1;
                            // }
                            catch (Exception ex1)
                            {
                                //CASCADE, WHICH MUST BRING TO DB is not opearatbale state
                                this._engine.DBisOperable       = false;
                                this._engine.DBisOperableReason = "TransactionsCoordinator.Commit tablesForTransaction.Count > 1";
                                throw new Exception(ex.ToString() + " --> " + ex1.ToString());
                            }

                            //In case if rollback succeeded we throw exception brough by bad commit

                            //CASCADE from LTrieRootNode.TransactionalCommit
                            throw ex;
                        }
                    } //end of foreach

                    //Here we appear if all tables were succesfully commited (but it's not visible still for READING THREDS and all tables still have their rollback files active)

                    //We have to finish the transaction
                    try
                    {
                        this._engine._transactionsJournal.FinishTransaction(tranNumber);
                    }
                    catch (OperationCanceledException ex)
                    {
                        throw ex;
                    }
                    //catch (System.Threading.ThreadAbortException ex)
                    // {
                    //     //We don'T make DBisOperable = false;
                    //     throw ex;
                    // }
                    catch (Exception ex)
                    {
                        this._engine.DBisOperable       = false;
                        this._engine.DBisOperableReason = "TransactionsCoordinator.Commit FinishTransaction";
                        throw ex;
                    }
                }
            }
            else
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TRANSACTION_DOESNT_EXIST);
            }
        }
예제 #30
0
        public void Rollback(int transactionThreadId)
        {
            if (!this._engine.DBisOperable)
            {
                return;
            }

            TransactionUnit transactionUnit = this.GetTransactionUnit(transactionThreadId);

            if (transactionUnit != null)
            {
                List <ITransactable> tablesForTransaction = transactionUnit.GetTransactionWriteTables();

                if (tablesForTransaction.Count() == 0)
                {
                    //DO NOTHING
                }
                else if (tablesForTransaction.Count() == 1)
                {
                    try
                    {
                        tablesForTransaction[0].SingleRollback();
                    }
                    catch (OperationCanceledException ex)
                    {
                        throw ex;
                    }
                    //catch (System.Threading.ThreadAbortException ex)
                    //{
                    //    //We don'T make DBisOperable = false;
                    //    throw ex;
                    //}
                    catch (Exception ex)
                    {
                        this._engine.DBisOperable       = false;
                        this._engine.DBisOperableReason = "TransactionsCoordinator.Rollback tablesForTransaction.Count = 1";
                        //CASCADE, WHICH MUST BRING TO DB is not opearatbale state
                        throw ex;
                    }
                }
                else
                {
                    //Rollback MANY AT ONCE
                    try
                    {
                        foreach (var tt1 in tablesForTransaction)
                        {
                            tt1.SingleRollback();
                        }
                    }
                    catch (OperationCanceledException ex)
                    {
                        throw ex;
                    }
                    //catch (System.Threading.ThreadAbortException ex1)
                    //{
                    //    //We don'T make DBisOperable = false;
                    //    throw ex1;
                    //}
                    catch (Exception ex1)
                    {
                        //CASCADE, WHICH MUST BRING TO DB is not opearatbale state
                        this._engine.DBisOperable       = false;
                        this._engine.DBisOperableReason = "TransactionsCoordinator.Rollback tablesForTransaction.Count > 1";
                        throw ex1;
                    }
                }
            }
            else
            {
                throw DBriizeException.Throw(DBriizeException.eDBriizeExceptions.TRANSACTION_DOESNT_EXIST);
            }
        }