예제 #1
0
        public void MergeExpiredTransactions(Session session)
        {
            long firstLiveTransactionTimestamp = base.GetFirstLiveTransactionTimestamp();

            while (true)
            {
                long     timestamp = 0L;
                object[] list      = null;
                lock (this.committedTransactionTimestamps)
                {
                    if (this.committedTransactionTimestamps.IsEmpty())
                    {
                        break;
                    }
                    timestamp = this.committedTransactionTimestamps.GetFirst();
                    if (timestamp >= firstLiveTransactionTimestamp)
                    {
                        break;
                    }
                    this.committedTransactionTimestamps.RemoveFirst();
                    list = this.committedTransactions.RemoveFirst();
                }
                TransactionManagerCommon.MergeTransaction(session, list, 0, list.Length, timestamp);
                base.FinaliseRows(session, list, 0, list.Length, true);
            }
        }
예제 #2
0
        public void MergeExpiredTransactions(Session session)
        {
            long firstLiveTransactionTimestamp = base.GetFirstLiveTransactionTimestamp();

            while (true)
            {
                long     first;
                object[] objArray;
                lock (this._committedTransactionTimestamps)
                {
                    if (this._committedTransactionTimestamps.IsEmpty())
                    {
                        break;
                    }
                    first = this._committedTransactionTimestamps.GetFirst();
                    if (first >= firstLiveTransactionTimestamp)
                    {
                        break;
                    }
                    this._committedTransactionTimestamps.RemoveFirst();
                    objArray = this._committedTransactions.RemoveFirst();
                }
                TransactionManagerCommon.MergeTransaction(session, objArray, 0, objArray.Length, first);
                base.FinaliseRows(session, objArray, 0, objArray.Length, true);
            }
        }
예제 #3
0
 public bool BeingActionTpl(Session session, Statement cs)
 {
     if (cs != null)
     {
         if (session.AbortTransaction)
         {
             return(false);
         }
         session.TempSet.Clear();
         if (cs.IsCatalogChange())
         {
             if (this._catalogWriteSession == null)
             {
                 this.GetTransactionSessions(session.TempSet);
                 session.TempSet.Remove(session);
                 if (session.TempSet.IsEmpty())
                 {
                     this._catalogWriteSession = session;
                     this._isLockedMode        = true;
                 }
                 else
                 {
                     this._catalogWriteSession = session;
                     this._isLockedMode        = true;
                     TransactionManagerCommon.SetWaitingSessionTpl(session);
                 }
                 return(true);
             }
             this._catalogWriteSession.WaitingSessions.Add(session);
             session.Latch.CountUp();
             return(true);
         }
         if (this._isLockedMode)
         {
             if ((cs.GetTableNamesForRead().Length == 0) && (cs.GetTableNamesForWrite().Length == 0))
             {
                 return(true);
             }
             if (cs.GetTableNamesForWrite().Length != 0)
             {
                 if (cs.GetTableNamesForWrite()[0].schema == SqlInvariants.LobsSchemaQname)
                 {
                     return(true);
                 }
             }
             else if ((cs.GetTableNamesForRead().Length != 0) && (cs.GetTableNamesForRead()[0].schema == SqlInvariants.LobsSchemaQname))
             {
                 return(true);
             }
             this._catalogWriteSession.WaitingSessions.Add(session);
             session.Latch.CountUp();
         }
     }
     return(true);
 }
예제 #4
0
        public bool CommitTransaction(Session session)
        {
            if (session.AbortTransaction)
            {
                return(false);
            }
            int count = session.RowActionList.Count;

            RowAction[] list = session.RowActionList.ToArray();
            lock (base.Lock)
            {
                for (int i = 0; i < count; i++)
                {
                    if (!list[i].CanCommit(session, session.TempSet))
                    {
                        return(false);
                    }
                }
                this.EndTransaction(session);
                session.ActionTimestamp         = base.NextChangeTimestamp();
                session.TransactionEndTimestamp = session.ActionTimestamp;
                for (int j = 0; j < count; j++)
                {
                    list[j].Commit(session);
                }
                for (int k = 0; k < session.TempSet.Size(); k++)
                {
                    session.TempSet.Get(k).AbortTransaction = true;
                }
                base.PersistCommit(session, list, count);
                if (base.GetFirstLiveTransactionTimestamp() > session.ActionTimestamp)
                {
                    TransactionManagerCommon.MergeTransaction(session, list, 0, count, session.ActionTimestamp);
                    base.FinaliseRows(session, list, 0, count, true);
                }
                else
                {
                    list = session.RowActionList.ToArray();
                    this.AddToCommittedQueue(session, list);
                }
                this.EndTransactionTpl(session);
                CountDownLatches(session);
            }
            session.TempSet.Clear();
            if ((session != base.LobSession) && (base.LobSession.RowActionList.Count > 0))
            {
                base.LobSession.IsTransaction = true;
                base.LobSession.ActionIndex   = base.LobSession.RowActionList.Count;
                base.LobSession.Commit(false);
                return(true);
            }
            return(true);
        }
예제 #5
0
 public void BeginAction(Session session, Statement cs)
 {
     if (!session.HasLocks(cs))
     {
         lock (base.Lock)
         {
             if (base.SetWaitedSessionsTpl(session, cs))
             {
                 if (session.TempSet.IsEmpty())
                 {
                     base.LockTablesTpl(session, cs);
                 }
                 else
                 {
                     TransactionManagerCommon.SetWaitingSessionTpl(session);
                 }
             }
         }
     }
 }
예제 #6
0
        public void RollbackPartial(Session session, int start, long timestamp)
        {
            object[] list  = session.RowActionList.ToArray();
            int      count = session.RowActionList.Count;

            if (start != count)
            {
                for (int i = start; i < count; i++)
                {
                    RowAction action = (RowAction)list[i];
                    if (action != null)
                    {
                        action.Rollback(session, timestamp);
                    }
                }
                TransactionManagerCommon.MergeRolledBackTransaction(session, timestamp, list, start, count);
                base.FinaliseRows(session, list, start, count, false);
                session.RowActionList.RemoveRange(start, session.RowActionList.Count - start);
            }
        }
예제 #7
0
        public bool CommitTransaction(Session session)
        {
            if (session.AbortTransaction)
            {
                return(false);
            }
            int count = session.RowActionList.Count;

            object[] list = session.RowActionList.ToArray();
            lock (base.Lock)
            {
                this.EndTransaction(session);
                session.ActionTimestamp = base.NextChangeTimestamp();
                for (int i = 0; i < count; i++)
                {
                    ((RowAction)list[i]).Commit(session);
                }
                base.PersistCommit(session, list, count);
                if (base.GetFirstLiveTransactionTimestamp() > session.ActionTimestamp)
                {
                    TransactionManagerCommon.MergeTransaction(session, list, 0, count, session.ActionTimestamp);
                    base.FinaliseRows(session, list, 0, count, true);
                }
                else
                {
                    list = session.RowActionList.ToArray();
                    this.AddToCommittedQueue(session, list);
                }
                this.EndTransactionTpl(session);
            }
            session.TempSet.Clear();
            if ((session != base.LobSession) && (base.LobSession.RowActionList.Count > 0))
            {
                base.LobSession.IsTransaction = true;
                base.LobSession.ActionIndex   = base.LobSession.RowActionList.Count;
                base.LobSession.Commit(false);
            }
            return(true);
        }