/// <summary>
 /// Initializes a new instance of the <see cref="CqlBatchTransaction" /> class.
 /// </summary>
 public CqlBatchTransaction()
 {
     _batchCommand = new CqlCommand {Transaction = this};
     _commands = new List<BatchFrame.BatchedCommand>();
     _batchType = CqlBatchType.Logged;
     _state = TransactionState.Pending;
 }

 internal void Begin()
 {
     try
     {
         if (_state == TransactionState.Active)
         {
             throw new InvalidOperationException("Transaction is already active");
         }
         CheckThread();
         if (_threadFlag != null)
         {
             throw new InvalidOperationException("Nested transactions are not allowed!");
         }
         _threadFlag = true;
         _startTime = Clock.CurrentTimeMillis();
         var request = TransactionCreateCodec.EncodeRequest(GetTimeoutMillis(), _options.GetDurability(),
             (int) _options.GetTransactionType(), _threadId);
         var response = Invoke(request);
         _txnId = TransactionCreateCodec.DecodeResponse(response).response;
         _state = TransactionState.Active;
     }
     catch (Exception e)
     {
         _threadFlag = null;
         throw ExceptionUtil.Rethrow(e);
     }
 }

 private EquityTransaction(int shares, double priceBuy, double priceSell, DateTime dateBuy, DateTime dateSell, TransactionState state)
 {
     Shares = shares;
     PriceBuy = priceBuy;
     PriceSell = priceSell;
     DateBuy = dateBuy;
     DateSell = dateSell;
     State = state;
 }

        public OutboundTransferModel GetOutsideTransferBySequenceNo(string seqNo, TransactionState txstate)
        {
            Check.Argument.IsNotEmpty(seqNo, "seqNo");

            return this.Context.Sql(getOutboundTransferBySequenceNo_Sql)
                               .Parameter("@seqNo", seqNo)
                               .Parameter("@state", txstate)
                               .QuerySingle<OutboundTransferModel>();
        }

        public InsideTransferModel GetInsideTransferBySequenceNo(string seqNo, TransactionState txstate, CurrencyType currency)
        {
            Check.Argument.IsNotEmpty(seqNo, "seqNo");

            return this.Context.Sql(getInsideTransferBySequenceNo_Sql.FormatWith(currency.ToString()))
                               .Parameter("@seqNo", seqNo)
                               .Parameter("@state", txstate)
                               .QuerySingle<InsideTransferModel>();
        }

 public TransactionCookie(int _transactionId, ILogger logImplement)
 {
     this._transactionId = _transactionId;
     _keyResults = new Dictionary<string, string>();
     _state = TransactionState._Unknown;
     _transactionCompletedEvent = new ManualResetEvent(false);
     _request = null;
     _response = null;
     _logger = logImplement;
 }

		public GdsTransaction(IDatabase db)
			: this()
		{
			if (!(db is GdsDatabase))
			{
				throw new ArgumentException("Specified argument is not of GdsDatabase type.");
			}

			_database = (GdsDatabase)db;
			_state = TransactionState.NoTransaction;
		}

		public ExtTransaction(IDatabase db)
		{
			if (!(db is ExtDatabase))
			{
				throw new ArgumentException("Specified argument is not of FesDatabase type.");
			}

			_db = (ExtDatabase)db;
			_state = TransactionState.NoTransaction;
			_statusVector = new int[IscCodes.ISC_STATUS_LENGTH];
		}

		public FesTransaction(IDatabase db)
		{
			if (!(db is FesDatabase))
			{
				throw new ArgumentException("Specified argument is not of FesDatabase type.");
			}

			this.db		= (FesDatabase)db;
			this.state	= TransactionState.NoTransaction;

			GC.SuppressFinalize(this);
		}

        public FesTransaction(IDatabase db)
        {
            if (!(db is FesDatabase))
            {
                throw new ArgumentException("Specified argument is not of FesDatabase type.");
            }

            this.db = (FesDatabase)db;
            this.state = TransactionState.NoTransaction;
            this.statusVector = new IntPtr[IscCodes.ISC_STATUS_LENGTH];

            GC.SuppressFinalize(this);
        }

		private DataServiceTransaction(DataService dataService) {
			_transactionState = TransactionState.Active;
			_dataService = dataService;
			_sendMessagesToPeers = true;
			_rollbackOnly = false;
			_outgoingMessages = new ArrayList();
			_processedMessageBatches = new ArrayList(1);
#if (NET_1_1)
			_updateCollectionMessages = new Hashtable(new ListHashCodeProvider(), new ListComparer());
			_clientUpdateCollectionMessages =  new Hashtable(new ListHashCodeProvider(), new ListComparer());
#else
			_updateCollectionMessages = new Hashtable(new ListHashCodeProvider());
			_clientUpdateCollectionMessages = new Hashtable(new ListHashCodeProvider());
#endif
		}

        /// <summary>
        /// Creates a new transaction having the given parameters.
        /// </summary>
        /// <param name="myDistributed">Indicates that this transaction should synched within the entire cluster.</param>
        /// <param name="myLongRunning">Indicates that this transaction is a long-running transaction.</param>
        /// <param name="myIsolationLevel">The isolation level of this transaction.</param>
        /// <param name="myName">A name or identification for this transaction.</param>
        /// <param name="myCreated"></param>
        /// <param name="myTransactionUUID"></param>
        public ATransaction(Boolean myDistributed = false, Boolean myLongRunning = false, IsolationLevel myIsolationLevel = IsolationLevel.Serializable, String myName = "", DateTime? myCreated = null, TransactionUUID myTransactionUUID = null)
        {
            UUID            = TransactionUUID.NewUUID;
            _State          = TransactionState.Running;

            if (myCreated.HasValue)
                Created     = myCreated.Value;
            else
                Created     = TimestampNonce.Now;

            IsolationLevel  = myIsolationLevel;
            Distributed     = myDistributed;
            LongRunning     = myLongRunning;
            Name            = myName;
        }

 public bool Delete(AccountClass account)
 {
     bool bResult = false;
     try
     {
         using (DbManager db = new DbManager())
         {
             Accessor.Query.Delete(db, account);
         }
         bResult = true;
     }
     catch (Exception except)
     {
         throw new System.ArgumentException(except.Message);
     }
     TransState = TransactionState.Default;
     return bResult;
 }

		internal DB2Transaction(DB2Connection con, IsolationLevel isoL)
		{
			long db2IsoL;
			db2Conn = con;
			short sqlRet;

			isolationLevel = isoL;

			switch (isoL) 
			{
				default:
				case System.Data.IsolationLevel.Chaos:				//No DB2equivalent, default to SQL_TXN_READ_COMMITTED
				case System.Data.IsolationLevel.ReadCommitted:		//SQL_TXN_READ_COMMITTED
					db2IsoL = DB2Constants.SQL_TXN_READ_COMMITTED;
					break;
				case System.Data.IsolationLevel.ReadUncommitted:	//SQL_TXN_READ_UNCOMMITTED
					db2IsoL = DB2Constants.SQL_TXN_READ_UNCOMMITTED;
					break;
				case System.Data.IsolationLevel.RepeatableRead:		//SQL_TXN_REPEATABLE_READ
					db2IsoL = DB2Constants.SQL_TXN_REPEATABLE_READ;
					break;
				case System.Data.IsolationLevel.Serializable:		//SQL_TXN_SERIALIZABLE_READ
					db2IsoL = DB2Constants.SQL_TXN_SERIALIZABLE_READ;
					break;
			}

			if(db2Conn.openConnection.autoCommit)
			{
				sqlRet = DB2CLIWrapper.SQLSetConnectAttr(db2Conn.DBHandle, DB2Constants.SQL_ATTR_AUTOCOMMIT, new IntPtr(DB2Constants.SQL_AUTOCOMMIT_OFF), 0);
				DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, "Error setting AUTOCOMMIT OFF in transaction CTOR.", db2Conn);
				db2Conn.openConnection.autoCommit = false;
			}
			sqlRet = DB2CLIWrapper.SQLSetConnectAttr(db2Conn.DBHandle, DB2Constants.SQL_ATTR_TXN_ISOLATION, new IntPtr(db2IsoL), 0);
			DB2ClientUtils.DB2CheckReturn(sqlRet, DB2Constants.SQL_HANDLE_DBC, db2Conn.DBHandle, "Error setting isolation level.", db2Conn);

			state = TransactionState.Open;
		}

		/// <summary>
		/// Clients can call this method to commit the transaction. You should only use this method if 
		/// you used the begin method to create the DataServiceTransaction. 
		/// Otherwise, the gateway will commit or rollback the transaction as necessary.
		/// </summary>
		public void Commit()
		{
			if( _rollbackOnly )
			{
				Rollback();
				return;
			}

			try
			{
                ProcessRefreshFills();

				_pushMessages = new ArrayList();
				for(int i = 0; i < _processedMessageBatches.Count; i++)
				{
					MessageBatch messageBatch = _processedMessageBatches[i] as MessageBatch;
					if( messageBatch.Messages != null && messageBatch.Messages.Count > 0 )
					{
						DataDestination dataDestination = _dataService.GetDestination(messageBatch.IncomingMessage) as DataDestination;
						try
						{
                            dataDestination.SequenceManager.ManageMessageBatch(messageBatch, this);
						}
						catch(Exception ex)
						{
							MessageException messageException = new MessageException(ex);
							ErrorMessage errorMessage = messageException.GetErrorMessage();
							errorMessage.correlationId = messageBatch.IncomingMessage.messageId;
							errorMessage.destination = messageBatch.IncomingMessage.destination;
							messageBatch.Messages.Clear();
							messageBatch.Messages.Add(errorMessage);
						}
						for(int j = 0; j < messageBatch.Messages.Count; j++)
						{
							IMessage message = messageBatch.Messages[j] as IMessage;

							if( !(message is ErrorMessage) )
								_pushMessages.Add(message);
						}
					}
					_outgoingMessages.AddRange(messageBatch.Messages);
				}
			
				for(int i = 0; i < _pushMessages.Count; i++)
				{
					IMessage message = _pushMessages[i] as IMessage;
					DataMessage dataMessage = message as DataMessage;
					if( dataMessage != null )
						PushMessage(GetSubscribers(message), message);
				}
				foreach(DictionaryEntry entry in _clientUpdateCollectionMessages)
				{
					UpdateCollectionMessage updateCollectionMessage = entry.Value as UpdateCollectionMessage;
					_outgoingMessages.Add(updateCollectionMessage);
					PushMessage(GetSubscribers(updateCollectionMessage), updateCollectionMessage);
				}
				foreach(DictionaryEntry entry in _updateCollectionMessages)
				{
					UpdateCollectionMessage updateCollectionMessage = entry.Value as UpdateCollectionMessage;
					_outgoingMessages.Add(updateCollectionMessage);
					PushMessage(GetSubscribers(updateCollectionMessage), updateCollectionMessage);
				}
			}
			finally
			{
				_transactionState = TransactionState.Committed;
			}
		}

		private void Dispose(bool disposing)
		{
			lock (_stateSyncRoot)
			{
				if (!_disposed)
				{
					try
					{
						Rollback();
					}
					catch
					{ }
					finally
					{
						if (disposing)
						{
							_database = null;
							_handle = 0;
							_state = TransactionState.NoTransaction;
						}

						_disposed = true;
					}
				}
			}
		}

		public void Prepare(byte[] buffer)
		{
			lock (_stateSyncRoot)
			{
				CheckTransactionState();

				try
				{
					_state = TransactionState.NoTransaction;

					lock (_database.SyncObject)
					{
						_database.XdrStream.Write(IscCodes.op_prepare2);
						_database.XdrStream.Write(_handle);
						_database.XdrStream.WriteBuffer(buffer, buffer.Length);
						_database.XdrStream.Flush();

						_database.ReadResponse();
					}

					_state = TransactionState.Prepared;
				}
				catch (IOException ex)
				{
					throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
				}
			}
		}

		public void RollbackRetaining()
		{
			lock (_stateSyncRoot)
			{
				CheckTransactionState();

				try
				{
					lock (_database.SyncObject)
					{
						_database.XdrStream.Write(IscCodes.op_rollback_retaining);
						_database.XdrStream.Write(_handle);
						_database.XdrStream.Flush();

						_database.ReadResponse();
					}

					_state = TransactionState.Active;
				}
				catch (IOException ex)
				{
					throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
				}
			}
		}

		public void Rollback()
		{
			lock (_stateSyncRoot)
			{
				CheckTransactionState();

				try
				{
					lock (_database.SyncObject)
					{
						_database.XdrStream.Write(IscCodes.op_rollback);
						_database.XdrStream.Write(_handle);
						_database.XdrStream.Flush();

						_database.ReadResponse();

						_database.TransactionCount--;
					}

					if (Update != null)
					{
						Update(this, new EventArgs());
					}

					_state = TransactionState.NoTransaction;
				}
				catch (IOException ex)
				{
					throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
				}
			}
		}

		public void BeginTransaction(TransactionParameterBuffer tpb)
		{
			lock (_stateSyncRoot)
			{
				if (_state != TransactionState.NoTransaction)
				{
					throw GetNoValidTransactionException();
				}

				try
				{
					GenericResponse response;
					lock (_database.SyncObject)
					{
						_database.XdrStream.Write(IscCodes.op_transaction);
						_database.XdrStream.Write(_database.Handle);
						_database.XdrStream.WriteBuffer(tpb.ToArray());
						_database.XdrStream.Flush();

						response = _database.ReadGenericResponse();

						_database.TransactionCount++;
					}

					_handle = response.ObjectHandle;
					_state = TransactionState.Active;
				}
				catch (IOException ex)
				{
					throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
				}
			}
		}