public BerkeleyBulkCursor(BerkeleyDb berkeleyDb, int bufferSize) :
base(berkeleyDb, bufferSize, BerkeleyDbMultiple.DB_MULTIPLE_KEY)
{
_deleteBuffer = new MultipleBuffer(bufferSize);
_deleteData = new List<Byte[]>();
_writeBuffer = new MultipleBuffer(bufferSize);
_writeData = new List<Dto.BerkeleyDtoPut>();
}
public BerkeleyBulkCursor(BerkeleyDb berkeleyDb, int bufferSize) :
base(berkeleyDb, bufferSize, BerkeleyDbMultiple.DB_MULTIPLE_KEY)
{
_deleteBuffer = new MultipleBuffer(bufferSize);
_deleteData = new List <Byte[]>();
_writeBuffer = new MultipleBuffer(bufferSize);
_writeData = new List <Dto.BerkeleyDtoPut>();
}
protected BerkeleyCursor(BerkeleyDb berkeleyDb, int bufferSize, BerkeleyDbCursorFlags mandatoryFlags)
{
_berkeleyDb = berkeleyDb;
_bufferSize = bufferSize;
_mandatoryFlags = mandatoryFlags;
_handle = InvalidHandle;
_methods = berkeleyDb.Methods.CreateCursorMethods();
}
protected BerkeleyCursor(BerkeleyDb berkeleyDb, int bufferSize, BerkeleyDbCursorFlags mandatoryFlags)
{
_berkeleyDb = berkeleyDb;
_bufferSize = bufferSize;
_mandatoryFlags = mandatoryFlags;
_handle = InvalidHandle;
_methods = berkeleyDb.Methods.CreateCursorMethods();
}
public override async Task<BerkeleyError> OpenDbAsync(BerkeleyDb db, String name, BerkeleyDbOpenFlags flags)
{
var requesrUri = "api/database/open/?handle=" + db.Handle.ToString() + "&name=" + name + "&flags=" + flags.ToStringEx();
HttpResponseMessage response = await _httpClient.GetAsync(requesrUri).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
return new BerkeleyError(response.StatusCode);
BerkeleyDbError error = await SerializeHelper.GetErrorAsync(_serializer, response.Content).ConfigureAwait(false);
return new BerkeleyError(error);
}
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);
}
public override async Task<BerkeleyResult<long>> CreateDb(BerkeleyDb berkeleyDb, BerkeleyDbFlags flags)
{
String requestUri = "api/database/create/?type=" + berkeleyDb.DbType.ToStringEx() + "&flags=" + flags.ToStringEx();
HttpResponseMessage response = await _httpClient.GetAsync(requestUri).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
return new BerkeleyResult<long>(response.StatusCode);
BerkeleyDtoResult dtoHandle = await SerializeHelper.GetResultAsync(_serializer, response.Content).ConfigureAwait(false);
if (dtoHandle.Error != 0)
return new BerkeleyResult<long>(dtoHandle.Error);
return new BerkeleyResult<long>(0, Int64.Parse(dtoHandle.Result));
}
public override async Task<BerkeleyResult<int>> GetPageSizeAsync(BerkeleyDb db)
{
String requestUri = "api/database/pagesize/?handle=" + db.Handle.ToString();
HttpResponseMessage response = await _httpClient.GetAsync(requestUri).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
return new BerkeleyResult<int>(response.StatusCode);
BerkeleyDtoResult dtoResult = await SerializeHelper.GetResultAsync(_serializer, response.Content).ConfigureAwait(false);
if (dtoResult.Error != 0)
return new BerkeleyResult<int>(dtoResult.Error);
int pageSize = Int32.Parse(dtoResult.Result);
return new BerkeleyResult<int>(pageSize);
}
private static BerkeleyDb CreateDb(BerkeleyDbFlags flags)
{
var client = new HttpClient();
client.BaseAddress = serviceRootUri;
var methods = new BerkeleyDbWebApiMethods(client, new Newtonsoft.Json.JsonSerializer(), new System.Net.Http.Formatting.JsonMediaTypeFormatter());
var bdb = new BerkeleyDb(methods, BerkeleyDbType.DB_BTREE, flags);
String fileName = Path.Combine(Path.GetTempPath(), "test.bdb");
File.Delete(fileName);
BerkeleyError error = bdb.OpenAsync(fileName, BerkeleyDbOpenFlags.DB_CREATE).Result;
error.ThrowIfError();
return bdb;
}
public abstract Task <BerkeleyError> CloseDbAsync(BerkeleyDb db, BerkeleyDbClose flags);
public abstract Task <BerkeleyError> WriteDuplicateAsync(BerkeleyDb db, Dto.BerkeleyDtoPut data, int bufferSize, BerkeleyDbWriteMode writeMode);
public BerkeleyBlobCursor(BerkeleyDb berkeleyDb, int bufferSize)
: base(berkeleyDb, bufferSize, BerkeleyDbCursorFlags.DB_CURSOR_BULK)
{
}
public abstract Task <BerkeleyResult <long> > CreateDb(BerkeleyDb berkeleyDb, BerkeleyDbFlags flags);
public BerkeleyKeyValueCursor(BerkeleyDb berkeleyDb)
: base(berkeleyDb, 0, 0)
{
}
public override async Task<BerkeleyResult<long>> OpenCursorAsync(BerkeleyDb db, BerkeleyDbCursorFlags flags)
{
String requestUri = "api/database/opencursor/?handle=" + db.Handle.ToString() + "&flags=" + flags.ToStringEx();
HttpResponseMessage response = await _httpClient.GetAsync(requestUri).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
return new BerkeleyResult<long>(response.StatusCode);
BerkeleyDtoResult result = await SerializeHelper.GetResultAsync(_serializer, response.Content).ConfigureAwait(false);
if (result.Error != 0)
return new BerkeleyResult<long>(result.Error);
return new BerkeleyResult<long>(0, Int64.Parse(result.Result));
}
public override async Task<BerkeleyError> WriteDuplicateAsync(BerkeleyDb db, BerkeleyDtoPut data, int bufferSize, BerkeleyDbWriteMode writeMode)
{
String requestUri;
BerkeleyDtoPut dataPost;
if (data.Key.Length <= bufferSize && data.Value.Length <= bufferSize)
{
requestUri = "api/database/writemultipleduplicate/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
dataPost = new BerkeleyDtoPut(data.Key, data.Value);
}
else
{
requestUri = "api/database/write/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
dataPost = data;
}
ObjectContent content = new ObjectContent<BerkeleyDtoPut>(dataPost, _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);
}
public BerkeleyKeyValueCursor(BerkeleyDb berkeleyDb)
: base(berkeleyDb, 0, 0)
{
}
public override async Task<BerkeleyError> WriteAsync(BerkeleyDb db, Byte[] key, Byte[] value, BerkeleyDbWriteMode writeMode)
{
String requestUri = "api/database/write/?handle=" + db.Handle.ToString() + "&writemode=" + writeMode.ToStringEx();
var data = new BerkeleyDtoPut(key, value);
var content = new ObjectContent<BerkeleyDtoPut>(data, _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);
}
private static void ReadFoto(BerkeleyDb bdb)
{
Byte[] key = System.Text.Encoding.UTF8.GetBytes("simple key/value");
using (var reader = new BerkeleyKeyValueCursor(bdb))
{
var result = reader.ReadAsync(key, BerkeleyDbOperation.DB_SET).Result;
File.WriteAllBytes(@"D:\zzz.jpg", result.Result.Value.ToArray());
}
}
public abstract Task <BerkeleyResult <int> > GetPageSizeAsync(BerkeleyDb db);
public abstract Task<BerkeleyError> CloseDbAsync(BerkeleyDb db, BerkeleyDbClose flags);
public abstract Task <BerkeleyResult <long> > OpenCursorAsync(BerkeleyDb db, BerkeleyDbCursorFlags flags);
public abstract Task <BerkeleyError> DeleteAsync(BerkeleyDb db, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple);
public BerkeleyBlobCursor(BerkeleyDb berkeleyDb, int bufferSize)
: base(berkeleyDb, bufferSize, BerkeleyDbCursorFlags.DB_CURSOR_BULK)
{
}
public abstract Task <BerkeleyError> OpenDbAsync(BerkeleyDb db, String name, BerkeleyDbOpenFlags flags);
public abstract Task<BerkeleyResult<long>> CreateDb(BerkeleyDb berkeleyDb, BerkeleyDbFlags flags);
public abstract Task <BerkeleyError> WriteAsync(BerkeleyDb db, Byte[] key, Byte[] value, BerkeleyDbWriteMode writeMode);
public abstract Task<BerkeleyError> DeleteAsync(BerkeleyDb db, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple);
public abstract Task <BerkeleyError> WriteMultipleAsync(BerkeleyDb db, Dto.BerkeleyDtoPut data, BerkeleyDbWriteMode writeMode);
public abstract Task<BerkeleyResult<int>> GetPageSizeAsync(BerkeleyDb db);
protected BerkeleyBulkCursorBase(BerkeleyDb berkeleyDb, int bufferSize, BerkeleyDbMultiple multiple)
: base(berkeleyDb, bufferSize, BerkeleyDbCursorFlags.DB_CURSOR_BULK)
{
_multiple = multiple;
}
public abstract Task<BerkeleyError> OpenDbAsync(BerkeleyDb db, String name, BerkeleyDbOpenFlags flags);
public abstract Task<BerkeleyResult<long>> OpenCursorAsync(BerkeleyDb db, BerkeleyDbCursorFlags flags);
public abstract Task<BerkeleyError> WriteAsync(BerkeleyDb db, Byte[] key, Byte[] value, BerkeleyDbWriteMode writeMode);
private static int GetPageSize(BerkeleyDb bdb)
{
BerkeleyResult<int> pageSizeResult = bdb.GetPageSizeAsync().Result;
pageSizeResult.Error.ThrowIfError();
return pageSizeResult.Result;
}
public abstract Task<BerkeleyError> WriteDuplicateAsync(BerkeleyDb db, Dto.BerkeleyDtoPut data, int bufferSize, BerkeleyDbWriteMode writeMode);
private static void WriteFoto(BerkeleyDb bdb, String fileName)
{
Byte[] key = System.Text.Encoding.UTF8.GetBytes(("simple key/value").ToString());
Byte[] value = File.ReadAllBytes(fileName);
var err = bdb.WriteAsync(key, value, 0).Result;
}
public abstract Task<BerkeleyError> WriteMultipleAsync(BerkeleyDb db, Dto.BerkeleyDtoPut data, BerkeleyDbWriteMode writeMode);
static void Main(string[] args)
{
var serviceRootUri = new Uri("http://*****:*****@"D:\гуманитарий с дипломом менеджера.jpg");
//ReadFoto(bdb);
}
}
}
protected BerkeleyBulkCursorBase(BerkeleyDb berkeleyDb, int bufferSize, BerkeleyDbMultiple multiple)
: base(berkeleyDb, bufferSize, BerkeleyDbCursorFlags.DB_CURSOR_BULK)
{
_multiple = multiple;
}
