public async Task<BerkeleyError> DeleteCurrentAsync(BerkeleyDbDelete flag = 0)
{
BerkeleyError error = await OpenAsync().ConfigureAwait(false);
if (error.HasError)
return error;
return await Methods.DeleteCurrentAsync(this, flag).ConfigureAwait(false);
}
public override async Task<BerkeleyError> DeleteCurrentAsync(BerkeleyCursor cursor, BerkeleyDbDelete flag)
{
String requestUri = "api/cursor/deletecurrent/?handle=" + cursor.Handle.ToString() + "&flag=" + flag.ToStringEx();
HttpResponseMessage response = await _httpClient.GetAsync(requestUri).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 async Task <BerkeleyError> DeleteCurrentAsync(BerkeleyDbDelete flag = 0)
{
BerkeleyError error = await OpenAsync().ConfigureAwait(false);
if (error.HasError)
{
return(error);
}
return(await Methods.DeleteCurrentAsync(this, flag).ConfigureAwait(false));
}
public static String ToStringEx(this BerkeleyDbDelete flags)
{
switch (flags)
{
case 0:
return("0");
case BerkeleyDbDelete.DB_CONSUME:
return("db_consume");
default:
throw new ArgumentOutOfRangeException(flags.ToString());
}
}
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();
}
}
public BerkeleyDbError Del(IntPtr pdbc, BerkeleyDbDelete flags)
{
return((BerkeleyDbError)_del(pdbc, (uint)flags));
}
public async Task<BerkeleyError> DeleteAsync(Byte[] key, BerkeleyDbDelete flag = 0)
{
return await base.BerkeleyDb.DeleteAsync(key, flag, 0).ConfigureAwait(false);
}
public BerkeleyDbError Del(IntPtr pdbc, BerkeleyDbDelete flags)
{
return (BerkeleyDbError)_del(pdbc, (uint)flags);
}
public async Task<BerkeleyError> DeleteAsync(Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple)
{
return await _methods.DeleteAsync(this, key, flag, multiple).ConfigureAwait(false);
}
public abstract Task <BerkeleyError> DeleteAsync(BerkeleyDb db, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple);
public abstract Task<BerkeleyError> DeleteAsync(BerkeleyDb db, Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple);
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));
}
public async Task <BerkeleyError> DeleteAsync(Byte[] key, BerkeleyDbDelete flag = 0)
{
return(await base.BerkeleyDb.DeleteAsync(key, flag, 0).ConfigureAwait(false));
}
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 async Task <BerkeleyError> DeleteAsync(Byte[] key, BerkeleyDbDelete flag, BerkeleyDbMultiple multiple)
{
return(await _methods.DeleteAsync(this, key, flag, multiple).ConfigureAwait(false));
}
public abstract Task <BerkeleyError> DeleteCurrentAsync(BerkeleyCursor cursor, BerkeleyDbDelete flag);
public BerkeleyDbError DeleteCurrent([FromUri] ulong handle, [FromUri] BerkeleyDbDelete flag)
{
DbcHandle dbc = GetDbc(handle);
return(dbc.Methods.Del(dbc.Handle, flag));
}
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();
}
}
public abstract Task<BerkeleyError> DeleteCurrentAsync(BerkeleyCursor cursor, BerkeleyDbDelete flag);
