コード例 #1
0
        public override void BeginTransaction(TransactionParameterBuffer tpb)
        {
            if (_state != TransactionState.NoTransaction)
            {
                throw new InvalidOperationException();
            }

            IscTeb teb     = new IscTeb();
            IntPtr tebData = IntPtr.Zero;

            try
            {
                ClearStatusVector();

                teb.dbb_ptr = Marshal.AllocHGlobal(4);
                Marshal.WriteInt32(teb.dbb_ptr, _db.Handle);

                teb.tpb_len = tpb.Length;

                teb.tpb_ptr = Marshal.AllocHGlobal(tpb.Length);
                Marshal.Copy(tpb.ToArray(), 0, teb.tpb_ptr, tpb.Length);

                int size = Marshal2.SizeOf <IscTeb>();
                tebData = Marshal.AllocHGlobal(size);

                Marshal.StructureToPtr(teb, tebData, true);

                _db.FbClient.isc_start_multiple(
                    _statusVector,
                    ref _handle,
                    1,
                    tebData);

                _db.ProcessStatusVector(_statusVector);

                _state = TransactionState.Active;

                _db.TransactionCount++;
            }
            catch
            {
                throw;
            }
            finally
            {
                if (teb.dbb_ptr != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(teb.dbb_ptr);
                }
                if (teb.tpb_ptr != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(teb.tpb_ptr);
                }
                if (tebData != IntPtr.Zero)
                {
                    Marshal2.DestroyStructure <IscTeb>(tebData);
                    Marshal.FreeHGlobal(tebData);
                }
            }
        }
コード例 #2
0
        public override byte[] GetSlice(int sliceLength)
        {
            ClearStatusVector();

            var dbHandle = _db.HandlePtr;
            var trHandle = _transaction.HandlePtr;

            var arrayDesc = ArrayDescMarshaler.MarshalManagedToNative(Descriptor);

            var buffer = new byte[sliceLength];

            _db.FbClient.isc_array_get_slice(
                _statusVector,
                ref dbHandle,
                ref trHandle,
                ref _handle,
                arrayDesc,
                buffer,
                ref sliceLength);

            ArrayDescMarshaler.CleanUpNativeData(ref arrayDesc);

            _db.ProcessStatusVector(_statusVector);

            return(buffer);
        }
コード例 #3
0
        public override byte[] GetSlice(int sliceLength)
        {
            // Clear the status vector
            ClearStatusVector();

            DatabaseHandle    dbHandle = _db.HandlePtr;
            TransactionHandle trHandle = _transaction.HandlePtr;

            IntPtr arrayDesc = ArrayDescMarshaler.MarshalManagedToNative(Descriptor);

            byte[] buffer = new byte[sliceLength];

            _db.FbClient.isc_array_get_slice(
                _statusVector,
                ref dbHandle,
                ref trHandle,
                ref _handle,
                arrayDesc,
                buffer,
                ref sliceLength);

            // Free	memory
            ArrayDescMarshaler.CleanUpNativeData(ref arrayDesc);

            _db.ProcessStatusVector(_statusVector);

            return(buffer);
        }
コード例 #4
0
        public override async Task Prepare(string commandText, AsyncWrappingCommonArgs async)
        {
            ClearAll();

            ClearStatusVector();

            if (State == StatementState.Deallocated)
            {
                Allocate();
            }

            _fields = new Descriptor(1);

            var sqlda = await XsqldaMarshaler.MarshalManagedToNative(_db.Charset, _fields, async).ConfigureAwait(false);

            var trHandle = _transaction.HandlePtr;

            var buffer = _db.Charset.GetBytes(commandText);

            _db.FbClient.isc_dsql_prepare(
                _statusVector,
                ref trHandle,
                ref _handle,
                (short)buffer.Length,
                buffer,
                _db.Dialect,
                sqlda);

            var descriptor = XsqldaMarshaler.MarshalNativeToManaged(_db.Charset, sqlda);

            XsqldaMarshaler.CleanUpNativeData(ref sqlda);

            _db.ProcessStatusVector(_statusVector);

            _fields = descriptor;

            if (_fields.ActualCount > 0 && _fields.ActualCount != _fields.Count)
            {
                await Describe(async).ConfigureAwait(false);
            }
            else
            {
                if (_fields.ActualCount == 0)
                {
                    _fields = new Descriptor(0);
                }
            }

            _fields.ResetValues();

            StatementType = await GetStatementType(async).ConfigureAwait(false);

            State = StatementState.Prepared;
        }
コード例 #5
0
        public override void Prepare(string commandText)
        {
            ClearAll();

            ClearStatusVector();

            if (_state == StatementState.Deallocated)
            {
                Allocate();
            }

            _fields = new Descriptor(1);

            IntPtr            sqlda    = XsqldaMarshaler.MarshalManagedToNative(_db.Charset, _fields);
            TransactionHandle trHandle = _transaction.HandlePtr;

            byte[] buffer = _db.Charset.GetBytes(commandText);

            _db.FbClient.isc_dsql_prepare(
                _statusVector,
                ref trHandle,
                ref _handle,
                (short)buffer.Length,
                buffer,
                _db.Dialect,
                sqlda);

            Descriptor descriptor = XsqldaMarshaler.MarshalNativeToManaged(_db.Charset, sqlda);

            XsqldaMarshaler.CleanUpNativeData(ref sqlda);

            _db.ProcessStatusVector(_statusVector);

            _fields = descriptor;

            if (_fields.ActualCount > 0 && _fields.ActualCount != _fields.Count)
            {
                Describe();
            }
            else
            {
                if (_fields.ActualCount == 0)
                {
                    _fields = new Descriptor(0);
                }
            }

            _fields.ResetValues();

            _statementType = GetStatementType();

            _state = StatementState.Prepared;
        }
コード例 #6
0
        protected override void Create()
        {
            ClearStatusVector();

            DatabaseHandle    dbHandle = _db.HandlePtr;
            TransactionHandle trHandle = ((FesTransaction)_transaction).HandlePtr;

            _db.FbClient.isc_create_blob2(
                _statusVector,
                ref dbHandle,
                ref trHandle,
                ref _blobHandle,
                ref _blobId,
                0,
                new byte[0]);

            _db.ProcessStatusVector(_statusVector);

            RblAddValue(IscCodes.RBL_create);
        }
コード例 #7
0
        protected override Task Create(AsyncWrappingCommonArgs async)
        {
            ClearStatusVector();

            var dbHandle = _db.HandlePtr;
            var trHandle = ((FesTransaction)_transaction).HandlePtr;

            _db.FbClient.isc_create_blob2(
                _statusVector,
                ref dbHandle,
                ref trHandle,
                ref _blobHandle,
                ref _blobId,
                0,
                new byte[0]);

            _db.ProcessStatusVector(_statusVector);

            RblAddValue(IscCodes.RBL_create);
            return(Task.CompletedTask);
        }
コード例 #8
0
        public override void Prepare(string commandText)
        {
            // Clear data
            ClearAll();

            lock (_db)
            {
                // Clear the status vector
                ClearStatusVector();

                // Allocate the statement if needed
                if (_state == StatementState.Deallocated)
                {
                    Allocate();
                }

                // Marshal structures to pointer


                // Setup fields	structure
                _fields = new Descriptor(1);

                IntPtr            sqlda    = XsqldaMarshaler.MarshalManagedToNative(_db.Charset, _fields);
                TransactionHandle trHandle = _transaction.HandlePtr;

                byte[] buffer = _db.Charset.GetBytes(commandText);

                _db.FbClient.isc_dsql_prepare(
                    _statusVector,
                    ref trHandle,
                    ref _handle,
                    (short)buffer.Length,
                    buffer,
                    _db.Dialect,
                    sqlda);

                // Marshal Pointer
                Descriptor descriptor = XsqldaMarshaler.MarshalNativeToManaged(_db.Charset, sqlda);

                // Free	memory
                XsqldaMarshaler.CleanUpNativeData(ref sqlda);

                // Parse status	vector
                _db.ProcessStatusVector(_statusVector);

                // Describe	fields
                _fields = descriptor;

                if (_fields.ActualCount > 0 && _fields.ActualCount != _fields.Count)
                {
                    Describe();
                }
                else
                {
                    if (_fields.ActualCount == 0)
                    {
                        _fields = new Descriptor(0);
                    }
                }

                // Reset actual	field values
                _fields.ResetValues();

                // Get Statement type
                _statementType = GetStatementType();

                // Update state
                _state = StatementState.Prepared;
            }
        }
コード例 #9
0
        public override void BeginTransaction(TransactionParameterBuffer tpb)
        {
            if (_state != TransactionState.NoTransaction)
            {
                throw new InvalidOperationException();
            }

            lock (_db)
            {
                IscTeb teb     = new IscTeb();
                IntPtr tebData = IntPtr.Zero;

                try
                {
                    // Clear the status vector
                    ClearStatusVector();

                    // Set db handle
                    teb.dbb_ptr = Marshal.AllocHGlobal(4);
                    Marshal.WriteInt32(teb.dbb_ptr, _db.Handle);

                    // Set tpb length
                    teb.tpb_len = tpb.Length;

                    // Set TPB data
                    teb.tpb_ptr = Marshal.AllocHGlobal(tpb.Length);
                    Marshal.Copy(tpb.ToArray(), 0, teb.tpb_ptr, tpb.Length);

                    // Alloc memory	for	the	IscTeb structure
                    int size = Marshal.SizeOf(typeof(IscTeb));
                    tebData = Marshal.AllocHGlobal(size);

                    Marshal.StructureToPtr(teb, tebData, true);

                    _db.FbClient.isc_start_multiple(
                        _statusVector,
                        ref _handle,
                        1,
                        tebData);

                    // Parse status	vector
                    _db.ProcessStatusVector(_statusVector);

                    // Update transaction state
                    _state = TransactionState.Active;

                    // Update transaction count
                    _db.TransactionCount++;
                }
                catch
                {
                    throw;
                }
                finally
                {
                    // Free	memory
                    if (teb.dbb_ptr != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(teb.dbb_ptr);
                    }
                    if (teb.tpb_ptr != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(teb.tpb_ptr);
                    }
                    if (tebData != IntPtr.Zero)
                    {
                        Marshal.DestroyStructure(tebData, typeof(IscTeb));
                        Marshal.FreeHGlobal(tebData);
                    }
                }
            }
        }