Beispiel #1
0
        protected override void Dispose(bool disposing)
        {
            if (!this.IsDisposed)
            {
                try
                {
                    // release any unmanaged resources
                    this.Release();

                    // release any managed resources
                    if (disposing)
                    {
                        this.Clear();

                        this.db              = null;
                        this.fields          = null;
                        this.parameters      = null;
                        this.transaction     = null;
                        this.outputParams    = null;
                        this.allRowsFetched  = false;
                        this.recordsAffected = 0;
                        this.state           = StatementState.Deallocated;
                        this.handle          = 0;
                    }
                }
                finally
                {
                    base.Dispose(disposing);
                }
            }
        }
Beispiel #2
0
        private void Dispose(bool disposing)
        {
            lock (this)
            {
                if (!this.disposed)
                {
                    try
                    {
                        // release any unmanaged resources
                        this.Rollback();

                        // release any managed resources
                        if (disposing)
                        {
                            this.db           = null;
                            this.handle       = 0;
                            this.state        = TransactionState.NoTransaction;
                            this.statusVector = null;
                        }
                    }
                    finally
                    {
                        this.disposed = true;
                    }
                }
            }
        }
        protected override void Dispose(bool disposing)
        {
            if (!IsDisposed)
            {
                try
                {
                    // release any unmanaged resources
                    Release();

                    // release any managed resources
                    if (disposing)
                    {
                        Clear();

                        _db              = null;
                        _fields          = null;
                        _parameters      = null;
                        _transaction     = null;
                        _outputParams    = null;
                        _allRowsFetched  = false;
                        _recordsAffected = 0;
                        _state           = StatementState.Deallocated;
                        _handle          = 0;
                    }
                }
                finally
                {
                    base.Dispose(disposing);
                }
            }
        }
		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];
		}
Beispiel #5
0
        public ExtTransaction(IDatabase db)
        {
            if (!(db is ExtDatabase))
            {
                throw new ArgumentException("Specified argument is not of FesDatabase type.");
            }

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

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

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

			GC.SuppressFinalize(this);
		}
        public ExtBlob(IDatabase db, ITransaction transaction, long blobId)
            : base(db)
        {
            if (!(db is ExtDatabase))
            {
                throw new ArgumentException("Specified argument is not of FesDatabase type.");
            }
            if (!(transaction is ExtTransaction))
            {
                throw new ArgumentException("Specified argument is not of FesTransaction type.");
            }

            this.db          = (ExtDatabase)db;
            this.transaction = (ExtTransaction)transaction;
            this.position    = 0;
            this.blobHandle  = 0;
            this.blobId      = blobId;
        }
		public ExtBlob(IDatabase db, ITransaction transaction, long blobId)
			: base(db)
		{
			if (!(db is ExtDatabase))
			{
				throw new ArgumentException("Specified argument is not of FesDatabase type.");
			}
			if (!(transaction is ExtTransaction))
			{
				throw new ArgumentException("Specified argument is not of FesTransaction type.");
			}

			_db = (ExtDatabase)db;
			_transaction = (ExtTransaction)transaction;
			_position = 0;
			_blobHandle = 0;
			_blobId = blobId;
		}
Beispiel #9
0
        public ExtStatement(IDatabase db, ITransaction transaction)
        {
            if (!(db is ExtDatabase))
            {
                throw new ArgumentException("Specified argument is not of FesDatabase type.");
            }

            this.recordsAffected = -1;
            this.db           = (ExtDatabase)db;
            this.outputParams = new Queue();

            if (transaction != null)
            {
                this.Transaction = transaction;
            }

            GC.SuppressFinalize(this);
        }
Beispiel #10
0
        public ExtStatement(IDatabase db, ITransaction transaction)
        {
            if (!(db is ExtDatabase))
            {
                throw new ArgumentException("Specified argument is not of FesDatabase type.");
            }

            this.recordsAffected = -1;
            this.db = (ExtDatabase)db;
            this.outputParams = new Queue();

            if (transaction != null)
            {
                this.Transaction = transaction;
            }

            GC.SuppressFinalize(this);
        }
Beispiel #11
0
        public ExtArray(
            IDatabase db,
            ITransaction transaction,
            long handle,
            string tableName,
            string fieldName)
            : base(tableName, fieldName)
        {
            if (!(db is ExtDatabase))
            {
                throw new ArgumentException("Specified argument is not of GdsDatabase type.");
            }
            if (!(transaction is ExtTransaction))
            {
                throw new ArgumentException("Specified argument is not of GdsTransaction type.");
            }
            this.db          = (ExtDatabase)db;
            this.transaction = (ExtTransaction)transaction;
            this.handle      = handle;

            this.LookupBounds();
        }
Beispiel #12
0
        public ExtArray(
            IDatabase db,
            ITransaction transaction,
            long handle,
            string tableName,
            string fieldName)
            : base(tableName, fieldName)
        {
            if (!(db is ExtDatabase))
            {
                throw new ArgumentException("Specified argument is not of GdsDatabase type.");
            }
            if (!(transaction is ExtTransaction))
            {
                throw new ArgumentException("Specified argument is not of GdsTransaction type.");
            }
            this.db = (ExtDatabase)db;
            this.transaction = (ExtTransaction)transaction;
            this.handle = handle;

            this.LookupBounds();
        }
Beispiel #13
0
        protected override void Dispose(bool disposing)
        {
            if (!this.IsDisposed)
            {
                try
                {
                    // release any unmanaged resources
                    this.Release();

                    // release any managed resources
                    if (disposing)
                    {
                        this.Clear();

                        this.db = null;
                        this.fields = null;
                        this.parameters = null;
                        this.transaction = null;
                        this.outputParams = null;
                        this.allRowsFetched = false;
                        this.recordsAffected = 0;
                        this.state = StatementState.Deallocated;
                        this.handle = 0;
                    }
                }
                finally
                {
                    base.Dispose(disposing);
                }
            }
        }
		private void Dispose(bool disposing)
		{
			lock (this)
			{
				if (!_disposed)
				{
					try
					{
						// release any unmanaged resources
						Rollback();

						// release any managed resources
						if (disposing)
						{
							_db = null;
							_handle = 0;
							_state = TransactionState.NoTransaction;
							_statusVector = null;
						}
					}
					finally
					{
						_disposed = true;
					}
				}
			}
		}
		protected override void Dispose(bool disposing)
		{
			if (!IsDisposed)
			{
				try
				{
					Release();
				}
				catch
				{ }

					if (disposing)
					{
						Clear();

						_db = null;
						_fields = null;
						_parameters = null;
						_transaction = null;
						_outputParams = null;
						_allRowsFetched = false;
						_recordsAffected = 0;
						_state = StatementState.Deallocated;
						_handle = 0;
					}

					base.Dispose(disposing);
				}
			}
		private void Dispose(bool disposing)
		{
			lock (this)
			{
				if (!_disposed)
				{
					try
					{
						Rollback();
					}
					catch
					{ }

					if (disposing)
					{
						_db = null;
						_handle = 0;
						_state = TransactionState.NoTransaction;
						_statusVector = null;
					}

					_disposed = true;
				}
			}
		}
		protected override void Dispose(bool disposing)
		{
			if (!IsDisposed)
			{
				try
				{
					// release any unmanaged resources
					Release();

					// release any managed resources
					if (disposing)
					{
						Clear();

						_db = null;
						_fields = null;
						_parameters = null;
						_transaction = null;
						_outputParams = null;
						_allRowsFetched = false;
						_recordsAffected = 0;
						_state = StatementState.Deallocated;
						_handle = 0;
					}
				}
				finally
				{
					base.Dispose(disposing);
				}
			}
		}
		public ExtStatement(IDatabase db, ITransaction transaction)
		{
			if (!(db is ExtDatabase))
			{
				throw new ArgumentException("Specified argument is not of FesDatabase type.");
			}

			_recordsAffected = -1;
			_db = (ExtDatabase)db;
			_outputParams = new Queue();

			if (transaction != null)
			{
				Transaction = transaction;
			}
		}