コード例 #1
0
        public override async Task<BerkeleyError> DeleteAsync(BerkeleyDb db, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple)
        {
            String requestUri = "api/database/delete/?handle=" + db.Handle.ToString() + "&flag=" + flag.ToStringEx() + "&multiple=" + multiple.ToStringEx();
            var content = new ObjectContent<Byte[]>(key, _formatter, (String)null);
            HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content).ConfigureAwait(false);
            if (!response.IsSuccessStatusCode)
                return new BerkeleyError(response.StatusCode);

            BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
            return new BerkeleyError(error);
        }
コード例 #2
0
        public override async Task<BerkeleyResult<BerkeleyDtoGet>> GetDtoGet(BerkeleyCursor cursor, Byte[] key, BerkeleyDbOperation operation, BerkeleyDbMultiple multiple, int bufferSize)
        {
            var requestUri = "api/cursor/read/?handle=" + cursor.Handle.ToString() + "&operation=" + operation.ToStringEx() + "&multiple=" + multiple.ToStringEx() + "&size=" + bufferSize.ToString();
            var content = new ObjectContent<Byte[]>(key, _formatter, (String)null);
            HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content).ConfigureAwait(false);
            if (!response.IsSuccessStatusCode)
                return new BerkeleyResult<BerkeleyDtoGet>(response.StatusCode);

            BerkeleyDtoGet berkeleyDataGet = await SerializeHelper.GetDataGetAsync(_serializer, response.Content).ConfigureAwait(false);
            return new BerkeleyResult<BerkeleyDtoGet>((BerkeleyDbError)berkeleyDataGet.ErrorCode, berkeleyDataGet);
        }
コード例 #3
0
        public static String ToStringEx(this BerkeleyDbMultiple flag)
        {
            switch (flag)
            {
            case 0:
                return("0");

            case BerkeleyDbMultiple.DB_MULTIPLE:
                return("db_multiple");

            case BerkeleyDbMultiple.DB_MULTIPLE_KEY:
                return("db_multiple_key");

            default:
                throw new ArgumentOutOfRangeException(flag.ToString());
            }
        }
コード例 #4
0
        public async Task <BerkeleyError> DeleteAsync()
        {
            CloseDeleteBuffer();

            foreach (Byte[] data in _deleteData)
            {
                BerkeleyDbMultiple multiple = data.Length > base.BufferSize ? 0 : BerkeleyDbMultiple.DB_MULTIPLE;
                BerkeleyError      error    = await base.BerkeleyDb.DeleteAsync(data, 0, multiple).ConfigureAwait(false);

                if (error.HasError)
                {
                    return(error);
                }
            }

            _deleteData.Clear();
            return(BerkeleyError.NoError);
        }
コード例 #5
0
        public BerkeleyDbError Del(IntPtr pdb, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple)
        {
            var keyDbt = new db_dbt();

            try
            {
                keyDbt.Init(key);
                keyDbt.flags |= db_dbt.DB_DBT_READONLY;
                if (multiple != 0)
                {
                    keyDbt.flags |= db_dbt.DB_DBT_BULK;
                }

                return((BerkeleyDbError)_del(pdb, IntPtr.Zero, ref keyDbt, (uint)flag | (uint)multiple));
            }
            finally
            {
                keyDbt.Dispose();
            }
        }
コード例 #6
0
 public async Task<BerkeleyError> DeleteAsync(Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple)
 {
     return await _methods.DeleteAsync(this, key, flag, multiple).ConfigureAwait(false);
 }
コード例 #7
0
 public abstract Task <BerkeleyError> DeleteAsync(BerkeleyDb db, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple);
コード例 #8
0
 public abstract Task<BerkeleyError> DeleteAsync(BerkeleyDb db, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple);
コード例 #9
0
        public BerkeleyDbError Get(IntPtr pdbc, Byte[] key, Byte[] data, BerkeleyDbOperation operation, BerkeleyDbMultiple multiple, out int keySize, out int dataSize)
        {
            var keyDbt  = new db_dbt();
            var dataDbt = new db_dbt();

            try
            {
                keyDbt.Init(key);
                dataDbt.Init(data.Length);

                var error = (BerkeleyDbError)_get(pdbc, ref keyDbt, ref dataDbt, (uint)operation | (uint)multiple);
                if (error == 0)
                {
                    keyDbt.CopyToArray(key);
                    dataDbt.CopyToArray(data);
                }

                keySize  = (int)keyDbt.size;
                dataSize = (int)dataDbt.size;
                return(error);
            }
            finally
            {
                keyDbt.Dispose();
                dataDbt.Dispose();
            }
        }
コード例 #10
0
 public abstract Task<BerkeleyResult<Dto.BerkeleyDtoGet>> GetDtoGet(BerkeleyCursor cursor, Byte[] key, BerkeleyDbOperation operation, BerkeleyDbMultiple multiple, int bufferSize);
コード例 #11
0
 public async Task <BerkeleyError> DeleteAsync(Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple)
 {
     return(await _methods.DeleteAsync(this, key, flag, multiple).ConfigureAwait(false));
 }
コード例 #12
0
 public abstract Task <BerkeleyResult <Dto.BerkeleyDtoGet> > GetDtoGet(BerkeleyCursor cursor, Byte[] key, BerkeleyDbOperation operation, BerkeleyDbMultiple multiple, int bufferSize);
コード例 #13
0
        public JToken Read([FromUri] ulong handle, [FromUri] BerkeleyDbOperation operation, [FromUri] BerkeleyDbMultiple multiple, [FromUri] int size, [FromBody] Byte[] key)
        {
            DbcHandle dbc = GetDbc(handle);

            if (key == null)
            {
                key = new Byte[size];
            }
            Byte[] value = new Byte[size];
            int    keySize, valueSize;

            BerkeleyDbError error = dbc.Methods.Get(dbc.Handle, key, value, operation, multiple, out keySize, out valueSize);

            if (error == BerkeleyDbError.DB_BUFFER_SMALL)
            {
                if (key.Length < keySize)
                {
                    key = new Byte[keySize];
                }
                if (value.Length < valueSize)
                {
                    value = new Byte[valueSize];
                }

                error = dbc.Methods.Get(dbc.Handle, key, value, operation, multiple, out keySize, out valueSize);
            }

            return(ControllersHelper.CreateJTokenObject(error, key, value, keySize, valueSize));
        }
コード例 #14
0
        public BerkeleyDbError Delete([FromUri] ulong handle, [FromUri] BerkeleyDbDelete flag, [FromUri] BerkeleyDbMultiple multiple, [FromBody] Byte[] key)
        {
            DbHandle db = GetDb(handle);

            return(db.Methods.Del(db.Handle, key, flag, multiple));
        }
コード例 #15
0
 protected BerkeleyBulkCursorBase(BerkeleyDb berkeleyDb, int bufferSize, BerkeleyDbMultiple multiple)
     : base(berkeleyDb, bufferSize, BerkeleyDbCursorFlags.DB_CURSOR_BULK)
 {
     _multiple = multiple;
 }
コード例 #16
0
        public BerkeleyDbError Get(IntPtr pdbc, Byte[] key, Byte[] data, BerkeleyDbOperation operation, BerkeleyDbMultiple multiple, out int keySize, out int dataSize)
        {
            var keyDbt = new db_dbt();
            var dataDbt = new db_dbt();
            try
            {
                keyDbt.Init(key);
                dataDbt.Init(data.Length);

                var error = (BerkeleyDbError)_get(pdbc, ref keyDbt, ref dataDbt, (uint)operation | (uint)multiple);
                if (error == 0)
                {
                    keyDbt.CopyToArray(key);
                    dataDbt.CopyToArray(data);
                }

                keySize = (int)keyDbt.size;
                dataSize = (int)dataDbt.size;
                return error;
            }
            finally
            {
                keyDbt.Dispose();
                dataDbt.Dispose();
            }
        }
コード例 #17
0
        public override async Task <BerkeleyError> DeleteAsync(BerkeleyDb db, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple)
        {
            String requestUri            = "api/database/delete/?handle=" + db.Handle.ToString() + "&flag=" + flag.ToStringEx() + "&multiple=" + multiple.ToStringEx();
            var    content               = new ObjectContent <Byte[]>(key, _formatter, (String)null);
            HttpResponseMessage response = await _httpClient.PostAsync(requestUri, content).ConfigureAwait(false);

            if (!response.IsSuccessStatusCode)
            {
                return(new BerkeleyError(response.StatusCode));
            }

            BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);

            return(new BerkeleyError(error));
        }
コード例 #18
0
        public BerkeleyDbError Del(IntPtr pdb, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple)
        {
            var keyDbt = new db_dbt();
            try
            {
                keyDbt.Init(key);
                keyDbt.flags |= db_dbt.DB_DBT_READONLY;
                if (multiple != 0)
                    keyDbt.flags |= db_dbt.DB_DBT_BULK;

                return (BerkeleyDbError)_del(pdb, IntPtr.Zero, ref keyDbt, (uint)flag | (uint)multiple);
            }
            finally
            {
                keyDbt.Dispose();
            }
        }
コード例 #19
0
 protected BerkeleyBulkCursorBase(BerkeleyDb berkeleyDb, int bufferSize, BerkeleyDbMultiple multiple)
     : base(berkeleyDb, bufferSize, BerkeleyDbCursorFlags.DB_CURSOR_BULK)
 {
     _multiple = multiple;
 }