Example #1
0
        public static ITransaction CreateTransaction(this IDatabase database, TransactionIsolation isolation)
        {
            if (!database.IsOpen)
                throw new InvalidOperationException(String.Format("Database '{0}' is not open.", database.Name()));

            return database.CreateSafeTransaction(isolation);
        }
Example #2
0
        public SessionInfo(int commitId, User user, TransactionIsolation isolation, ConnectionEndPoint endPoint)
        {
            if (user == null)
                throw new ArgumentNullException("user");
            if (endPoint == null)
                throw new ArgumentNullException("endPoint");

            CommitId = commitId;
            User = user;
            EndPoint = endPoint;
            Isolation = isolation;
            StartedOn = DateTimeOffset.UtcNow;
        }
        private static IsolationLevel GetIsolationLevel(TransactionIsolation level)
        {
            switch (level)
            {
                case TransactionIsolation.ReadUncommitted:
                    return IsolationLevel.ReadUncommitted;

                case TransactionIsolation.RepeatableRead:
                    return IsolationLevel.RepeatableRead;

                case TransactionIsolation.Serializable:
                    return IsolationLevel.Serializable;

                case TransactionIsolation.Snapshot:
                    return IsolationLevel.Snapshot;

                default:
                    return IsolationLevel.ReadCommitted;
            }
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="TransactionsImpl" /> class.
        /// </summary>
        /// <param name="target">Target.</param>
        /// <param name="marsh">Marshaller.</param>
        /// <param name="localNodeId">Local node id.</param>
        public TransactionsImpl(IUnmanagedTarget target, Marshaller marsh,
            Guid localNodeId) : base(target, marsh)
        {
            _localNodeId = localNodeId;

            TransactionConcurrency concurrency = default(TransactionConcurrency);
            TransactionIsolation isolation = default(TransactionIsolation);
            TimeSpan timeout = default(TimeSpan);

            DoInOp(OpCacheConfigParameters, stream =>
            {
                var reader = marsh.StartUnmarshal(stream).GetRawReader();

                concurrency = (TransactionConcurrency) reader.ReadInt();
                isolation = (TransactionIsolation) reader.ReadInt();
                timeout = TimeSpan.FromMilliseconds(reader.ReadLong());
            });

            _dfltConcurrency = concurrency;
            _dfltIsolation = isolation;
            _dfltTimeout = timeout;
        }
Example #5
0
        internal Transaction(Database database, int commitId, TransactionIsolation isolation, IEnumerable<TableSource> committedTables, IEnumerable<IIndexSet> indexSets)
        {
            CommitId = commitId;
            Database = database;
            Isolation = isolation;

            InitManagers();

            Registry = new TransactionRegistry(this);
            tableManager.AddVisibleTables(committedTables, indexSets);

            AddInternalTables();

            OldNewTableState = new OldNewTableState();

            IsClosed = false;

            Database.TransactionFactory.OpenTransactions.AddTransaction(this);

            currentSchema = database.DatabaseContext.DefaultSchema();
            readOnly = dbReadOnly = database.DatabaseContext.ReadOnly();
            autoCommit = database.DatabaseContext.AutoCommit();
            ignoreCase = database.DatabaseContext.IgnoreIdentifiersCase();
        }
Example #6
0
 internal Transaction(Database database, int commitId, TransactionIsolation isolation)
     : this(database, commitId, isolation, new TableSource[0], new IIndexSet[0])
 {
 }
Example #7
0
        public int BeginTransaction(TransactionIsolation isolationLevel)
        {
            var response = SendMessage(new BeginRequest(isolationLevel))
                as BeginResponse;

            if (response == null)
                throw new InvalidOperationException();

            return response.CommitId;
        }
Example #8
0
        public ITransaction TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation,
            TimeSpan timeout, int txSize)
        {
            var id = DoOutInOp(OpStart, w =>
            {
                w.WriteInt((int) concurrency);
                w.WriteInt((int) isolation);
                w.WriteTimeSpanAsLong(timeout);
                w.WriteInt(txSize);
            }, s => s.ReadLong());

            var innerTx = new TransactionImpl(id, this, concurrency, isolation, timeout, _localNodeId);
            
            return new Transaction(innerTx);
        }
Example #9
0
        internal ITransaction CreateTransaction(TransactionIsolation isolation)
        {
            var thisCommittedTables = new List<TableSource>();

            // Don't let a commit happen while we are looking at this.
            lock (commitLock) {
                int thisCommitId = CurrentCommitId;
                var committedTableList = StateStore.GetVisibleList();
                thisCommittedTables.AddRange(committedTableList.Select(resource => GetTableSource(resource.TableId)));

                // Create a set of IIndexSet for all the tables in this transaction.
                var indexInfo = (thisCommittedTables.Select(mtable => mtable.CreateIndexSet())).ToList();

                // Create the transaction and record it in the open transactions list.
                return new Transaction(Database, thisCommitId, isolation, thisCommittedTables, indexInfo);
            }
        }
Example #10
0
 /** <inheritDoc /> */
 public ITransaction TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation)
 {
     return(TxStart(concurrency, isolation, _dfltTimeout, 0));
 }
Example #11
0
 /** <inheritDoc /> */
 public ITransactionClient TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation)
 {
     return(TxStart(concurrency, isolation, DefaultTimeout));
 }
Example #12
0
 public SessionInfo(int commitId, User user, TransactionIsolation isolation)
     : this(commitId, user, isolation, ConnectionEndPoint.Embedded)
 {
 }
Example #13
0
 /// <inheritdoc />
 public void Start(TransactionScopeOption transactionScopeOption, TransactionIsolation transactionIsolation, int transactionTimespan)
 {
     // Do Nothing
 }
Example #14
0
 /** <inheritDoc /> */
 public ITransaction TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation)
 {
     return TxStart(concurrency, isolation, _dfltTimeout, 0);
 }
Example #15
0
 public static IUserSession CreateSystemSession(this IDatabase database, TransactionIsolation isolation)
 {
     var transaction = database.CreateTransaction(isolation);
     return new SystemUserSession(database, transaction);
 }
Example #16
0
 internal static ITransaction CreateSafeTransaction(this IDatabase database, TransactionIsolation isolation)
 {
     return database.TransactionFactory.CreateTransaction(isolation);
 }
Example #17
0
 public BeginRequest(TransactionIsolation isolationLevel)
 {
     IsolationLevel = isolationLevel;
 }
 public static ITransaction BeginTransaction(this ISession session, TransactionIsolation level)
 {
     return session.BeginTransaction(GetIsolationLevel(level));
 }
Example #19
0
 public SessionInfo(User user, TransactionIsolation isolation, ConnectionEndPoint endPoint)
     : this(-1, user, isolation, endPoint)
 {
 }
Example #20
0
 /** <inheritDoc /> */
 public ITransactionClient TxStart(TransactionConcurrency concurrency,
                                   TransactionIsolation isolation,
                                   TimeSpan timeout)
 {
     return(TxStart(concurrency, isolation, timeout, null));
 }
Example #21
0
            public ITransaction CreateTransaction(TransactionIsolation isolation)
            {
                lock (this) {
                    ITransaction transaction;

                    try {
                        transaction = database.TableComposite.CreateTransaction(isolation);
                    } catch (DatabaseSystemException) {
                        throw;
                    } catch (Exception ex) {
                        throw new DatabaseSystemException("Unable to create a transaction.", ex);
                    }

                    return transaction;
                }
            }
Example #22
0
 public SessionInfo(User user, TransactionIsolation isolation)
     : this(-1, user, isolation)
 {
 }
Example #23
0
        /** <inheritDoc /> */
        public ITransaction TxStart(TransactionConcurrency concurrency, TransactionIsolation isolation,
            TimeSpan timeout, int txSize)
        {
            var id = UU.TransactionsStart(Target, (int)concurrency, (int)isolation, (long)timeout.TotalMilliseconds,
                txSize);

            var innerTx = new TransactionImpl(id, this, concurrency, isolation, timeout, _localNodeId);
            
            return new Transaction(innerTx);
        }
Example #24
0
 public ITransaction StartTransaction(TransactionConcurrency concurrency, TransactionIsolation isolation)
 {
     return((ignite ?? DIContext.Obtain <ITRexGridFactory>().Grid(Mutability))
            .GetTransactions()
            .TxStart(concurrency, isolation));
 }