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();
}
}
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));
}
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);
}
public async Task<BerkeleyResult<BerkeleyKeyValue>> ReadAsync(Byte[] key, BerkeleyDbOperation operation)
{
BerkeleyError error = await base.OpenAsync().ConfigureAwait(false);
if (error.HasError)
return new BerkeleyResult<BerkeleyKeyValue>(error);
BerkeleyResult<Dto.BerkeleyDtoGet> resultDtoGet = await base.Methods.GetDtoGet(this, key, operation, 0, 0).ConfigureAwait(false);
if (resultDtoGet.HasError)
return new BerkeleyResult<BerkeleyKeyValue>(resultDtoGet.Error);
var keyValue = new BerkeleyKeyValue(resultDtoGet.Result.Key, resultDtoGet.Result.Value);
return new BerkeleyResult<BerkeleyKeyValue>(keyValue);
}
protected async Task<BerkeleyError> SetBuffer(Byte[] key, BerkeleyDbOperation operation)
{
BerkeleyError error = await base.OpenAsync().ConfigureAwait(false);
if (error.HasError)
return error;
BerkeleyResult<Dto.BerkeleyDtoGet> resultDtoGet = await base.Methods.GetDtoGet(this, key, operation, _multiple, base.BufferSize).ConfigureAwait(false);
if (!resultDtoGet.HasError)
{
Dto.BerkeleyDtoGet dtoGet = resultDtoGet.Result;
SetDtoGet(ref dtoGet);
}
return resultDtoGet.Error;
}
protected async Task <BerkeleyError> SetBuffer(Byte[] key, BerkeleyDbOperation operation)
{
BerkeleyError error = await base.OpenAsync().ConfigureAwait(false);
if (error.HasError)
{
return(error);
}
BerkeleyResult <Dto.BerkeleyDtoGet> resultDtoGet = await base.Methods.GetDtoGet(this, key, operation, _multiple, base.BufferSize).ConfigureAwait(false);
if (!resultDtoGet.HasError)
{
Dto.BerkeleyDtoGet dtoGet = resultDtoGet.Result;
SetDtoGet(ref dtoGet);
}
return(resultDtoGet.Error);
}
public async Task <BerkeleyResult <BerkeleyKeyValue> > ReadAsync(Byte[] key, BerkeleyDbOperation operation)
{
BerkeleyError error = await base.OpenAsync().ConfigureAwait(false);
if (error.HasError)
{
return(new BerkeleyResult <BerkeleyKeyValue>(error));
}
BerkeleyResult <Dto.BerkeleyDtoGet> resultDtoGet = await base.Methods.GetDtoGet(this, key, operation, 0, 0).ConfigureAwait(false);
if (resultDtoGet.HasError)
{
return(new BerkeleyResult <BerkeleyKeyValue>(resultDtoGet.Error));
}
var keyValue = new BerkeleyKeyValue(resultDtoGet.Result.Key, resultDtoGet.Result.Value);
return(new BerkeleyResult <BerkeleyKeyValue>(keyValue));
}
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();
}
}
public async Task <BerkeleyBulkEnumerator> ReadAsync(Byte[] key, BerkeleyDbOperation operation)
{
BerkeleyError error = await SetBuffer(key, operation).ConfigureAwait(false);
return(error.HasError ? new BerkeleyBulkEnumerator(error) : new BerkeleyBulkEnumerator(this));
}
public abstract Task <BerkeleyResult <Dto.BerkeleyDtoGet> > GetDtoGet(BerkeleyCursor cursor, Byte[] key, BerkeleyDbOperation operation, BerkeleyDbMultiple multiple, int bufferSize);
public static String ToStringEx(this BerkeleyDbOperation flag)
{
switch (flag)
{
case 0:
return("0");
case BerkeleyDbOperation.DB_AFTER:
return("db_after");
case BerkeleyDbOperation.DB_CONSUME:
return("db_consume");
case BerkeleyDbOperation.DB_CURRENT:
return("db_current");
case BerkeleyDbOperation.DB_FIRST:
return("db_first");
case BerkeleyDbOperation.DB_GET_BOTH:
return("db_get_both");
case BerkeleyDbOperation.DB_GET_BOTH_RANGE:
return("db_get_both_range");
case BerkeleyDbOperation.DB_GET_RECNO:
return("db_get_recno");
case BerkeleyDbOperation.DB_JOIN_ITEM:
return("db_join_item");
case BerkeleyDbOperation.DB_KEYFIRST:
return("db_keyfirst");
case BerkeleyDbOperation.DB_KEYLAST:
return("db_keylast");
case BerkeleyDbOperation.DB_LAST:
return("db_last");
case BerkeleyDbOperation.DB_NEXT:
return("db_next");
case BerkeleyDbOperation.DB_NEXT_DUP:
return("db_next_dup");
case BerkeleyDbOperation.DB_NEXT_NODUP:
return("db_next_nodup");
case BerkeleyDbOperation.DB_NODUPDATA:
return("db_nodupdata");
case BerkeleyDbOperation.DB_PREV:
return("db_prev");
case BerkeleyDbOperation.DB_PREV_DUP:
return("db_prev_dup");
case BerkeleyDbOperation.DB_PREV_NODUP:
return("db_prev_nodup");
case BerkeleyDbOperation.DB_SET:
return("db_set");
case BerkeleyDbOperation.DB_SET_RANGE:
return("db_set_range");
case BerkeleyDbOperation.DB_SET_RECNO:
return("db_set_recno");
default:
throw new ArgumentOutOfRangeException(flag.ToString());
}
}
public abstract Task<BerkeleyResult<Dto.BerkeleyDtoGet>> GetDtoGet(BerkeleyCursor cursor, Byte[] key, BerkeleyDbOperation operation, BerkeleyDbMultiple multiple, int bufferSize);
public async Task<BerkeleyBulkEnumerator> ReadAsync(Byte[] key, BerkeleyDbOperation operation)
{
BerkeleyError error = await SetBuffer(key, operation).ConfigureAwait(false);
return error.HasError ? new BerkeleyBulkEnumerator(error) : new BerkeleyBulkEnumerator(this);
}
