public void MultipleTransactions2(int transactionCount)
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
var key = new byte[2 + transactionCount * 10];
for (int i = 0; i < transactionCount; i++)
{
key[0] = (byte)((transactionCount - i) / 256);
key[1] = (byte)((transactionCount - i) % 256);
using (var tr1 = db.StartTransaction())
{
tr1.CreateOrUpdateKeyValue(ByteBuffer.NewSync(key, 0, 2 + i * 10), ByteBuffer.NewEmpty());
if (i % 100 == 0 || i == transactionCount - 1)
{
for (int j = 0; j < i; j++)
{
key[0] = (byte)((transactionCount - j) / 256);
key[1] = (byte)((transactionCount - j) % 256);
Assert.Equal(FindResult.Exact, tr1.Find(ByteBuffer.NewSync(key, 0, 2 + j * 10)));
}
}
tr1.Commit();
}
}
}
}
public void SetKeyIndexWorks()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
var key = new byte[2];
const int keysCreated = 10000;
using (var tr = db.StartTransaction())
{
for (int i = 0; i < keysCreated; i++)
{
key[0] = (byte)(i / 256);
key[1] = (byte)(i % 256);
tr.CreateKey(key);
}
tr.Commit();
}
using (var tr = db.StartTransaction())
{
Assert.False(tr.SetKeyIndex(keysCreated));
for (int i = 0; i < keysCreated; i += 5)
{
Assert.True(tr.SetKeyIndex(i));
key = tr.GetKeyAsByteArray();
Assert.Equal((byte)(i / 256), key[0]);
Assert.Equal((byte)(i % 256), key[1]);
Assert.Equal(i, tr.GetKeyIndex());
}
}
}
}
public void TwoTransactions()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr1 = db.StartTransaction())
{
tr1.CreateKey(_key1);
tr1.Commit();
}
using (var tr2 = db.StartTransaction())
{
tr2.CreateKey(_key2);
Assert.True(tr2.FindExactKey(_key1));
Assert.True(tr2.FindExactKey(_key2));
Assert.False(tr2.FindExactKey(_key3));
tr2.Commit();
}
using (var tr3 = db.StartTransaction())
{
Assert.True(tr3.FindExactKey(_key1));
Assert.True(tr3.FindExactKey(_key2));
Assert.False(tr3.FindExactKey(_key3));
}
}
}
public void CompressibleValueLoad()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using var tr = db.StartTransaction();
tr.CreateOrUpdateKeyValue(_key1, new byte[1000]);
Assert.Equal(new byte[1000], tr.GetValue().ToArray());
tr.Commit();
}
static ObjectDB CreateInMemoryDb()
{
var lowDb = new InMemoryKeyValueDB();
var db = new ObjectDB();
db.Open(lowDb, true);
return(db);
}
public void OnlyOneWritingTransactionPossible()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using var tr1 = db.StartTransaction();
tr1.CreateKey(_key1);
using var tr2 = db.StartTransaction();
Assert.False(tr2.FindExactKey(_key1));
Assert.Throws <BTDBTransactionRetryException>(() => tr2.CreateKey(_key2));
}
public void FirstTransactionIsNumber1()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using var tr = db.StartTransaction();
Assert.Equal(0, tr.GetTransactionNumber());
Assert.True(tr.CreateOrUpdateKeyValue(_key1, new byte[0]));
Assert.Equal(1, tr.GetTransactionNumber());
tr.Commit();
}
public void ReadOnlyTransactionThrowsOnWriteAccess()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartReadOnlyTransaction())
{
Assert.Throws <BTDBTransactionRetryException>(() => tr.CreateKey(new byte[1]));
}
}
}
public void PrefixWithFindPrevKeyWorks()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using var tr = db.StartTransaction();
tr.CreateKey(_key1);
tr.CreateKey(_key2);
Assert.True(tr.FindFirstKey(_key2.AsSpan(0, 1)));
Assert.False(tr.FindPreviousKey(_key2.AsSpan(0, 1)));
tr.Commit();
}
public void EmptyWritingTransaction()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartWritingTransaction().Result)
{
tr.Commit();
}
}
}
public void CanGetSizeOfPair()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using var tr = db.StartTransaction();
tr.CreateOrUpdateKeyValue(_key1, new byte[1]);
var s = tr.GetStorageSizeOfCurrentKey();
Assert.Equal(_key1.Length, (int)s.Key);
Assert.Equal(1u, s.Value);
}
public void EmptyTransaction()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartTransaction())
{
tr.Commit();
}
}
}
public void FirstTransaction()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartTransaction())
{
Assert.True(tr.CreateOrUpdateKeyValue(ByteBuffer.NewAsync(_key1), ByteBuffer.NewAsync(new byte[0])));
tr.Commit();
}
}
}
public void FindLastKeyWorks()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using var tr = db.StartTransaction();
Assert.False(tr.FindLastKey(ReadOnlySpan <byte> .Empty));
tr.CreateKey(_key1);
tr.CreateKey(_key2);
tr.CreateKey(_key3);
Assert.True(tr.FindLastKey(ReadOnlySpan <byte> .Empty));
Assert.Equal(_key2, tr.GetKey().ToArray());
tr.Commit();
}
public void ALotOf5KbTransactionsWorks()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
for (var i = 0; i < 5000; i++)
{
var key = new byte[5000];
using var tr = db.StartTransaction();
key[0] = (byte)(i / 256);
key[1] = (byte)(i % 256);
Assert.True(tr.CreateKey(key));
tr.Commit();
}
}
public void CanGetSizeOfPair()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartTransaction())
{
tr.CreateOrUpdateKeyValue(ByteBuffer.NewAsync(_key1), ByteBuffer.NewAsync(new byte[1]));
var s = tr.GetStorageSizeOfCurrentKey();
Assert.Equal(_key1.Length, (int)s.Key);
Assert.Equal(1u, s.Value);
}
}
}
public void FindKeyWithPreferPreviousKeyWorks()
{
const int keyCount = 10000;
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartTransaction())
{
var key = new byte[100];
for (int i = 0; i < keyCount; i++)
{
key[0] = (byte)(i / 256);
key[1] = (byte)(i % 256);
tr.CreateKey(key);
}
tr.Commit();
}
using (var tr = db.StartTransaction())
{
var key = new byte[101];
for (int i = 0; i < keyCount; i++)
{
key[0] = (byte)(i / 256);
key[1] = (byte)(i % 256);
var findKeyResult = tr.Find(ByteBuffer.NewSync(key));
Assert.Equal(FindResult.Previous, findKeyResult);
Assert.Equal(i, tr.GetKeyIndex());
}
}
using (var tr = db.StartTransaction())
{
var key = new byte[99];
for (int i = 0; i < keyCount; i++)
{
key[0] = (byte)(i / 256);
key[1] = (byte)(i % 256);
var findKeyResult = tr.Find(ByteBuffer.NewSync(key));
if (i == 0)
{
Assert.Equal(FindResult.Next, findKeyResult);
Assert.Equal(i, tr.GetKeyIndex());
}
else
{
Assert.Equal(FindResult.Previous, findKeyResult);
Assert.Equal(i - 1, tr.GetKeyIndex());
}
}
}
}
}
public void MoreComplexTransaction()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using var tr = db.StartTransaction();
Assert.True(tr.CreateOrUpdateKeyValue(_key1, ReadOnlySpan <byte> .Empty));
Assert.False(tr.CreateOrUpdateKeyValue(_key1, ReadOnlySpan <byte> .Empty));
Assert.Equal(FindResult.Previous, tr.Find(_key2, 0));
Assert.True(tr.CreateOrUpdateKeyValue(_key2, ReadOnlySpan <byte> .Empty));
Assert.Equal(FindResult.Exact, tr.Find(_key1, 0));
Assert.Equal(FindResult.Exact, tr.Find(_key2, 0));
Assert.Equal(FindResult.Previous, tr.Find(_key3, 0));
Assert.Equal(FindResult.Next, tr.Find(ReadOnlySpan <byte> .Empty, 0));
tr.Commit();
}
public void CommitWithUlongWorks()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using (var tr1 = db.StartTransaction())
{
Assert.Equal(0ul, tr1.GetCommitUlong());
tr1.SetCommitUlong(42);
tr1.Commit();
}
using (var tr2 = db.StartTransaction())
{
Assert.Equal(42ul, tr2.GetCommitUlong());
}
}
public void RollbackWorks()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using (var tr1 = db.StartTransaction())
{
tr1.CreateKey(_key1);
// Rollback because of missing commit
}
using (var tr2 = db.StartTransaction())
{
Assert.Equal(0, tr2.GetTransactionNumber());
Assert.False(tr2.FindExactKey(_key1));
}
}
public void PrefixWithFindPrevKeyWorks()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartTransaction())
{
tr.CreateKey(_key1);
tr.CreateKey(_key2);
tr.SetKeyPrefix(ByteBuffer.NewAsync(_key2, 0, 1));
Assert.True(tr.FindFirstKey());
Assert.False(tr.FindPreviousKey());
tr.Commit();
}
}
}
public void SimplePrefixWorks()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using var tr = db.StartTransaction();
tr.CreateKey(_key1);
tr.CreateKey(_key2);
tr.CreateKey(_key3);
Assert.Equal(3, tr.GetKeyValueCount());
Assert.Equal(2, tr.GetKeyValueCount(_key1));
tr.FindFirstKey(_key1.AsSpan(0, 3));
Assert.Equal(_key1, tr.GetKey().ToArray());
tr.FindLastKey(_key1.AsSpan(0, 3));
Assert.Equal(_key3, tr.GetKey().ToArray());
tr.Commit();
}
public void TwoEmptyWriteTransactionsWithNestedWaiting()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
Task <IKeyValueDBTransaction> trOuter;
using (var tr = db.StartWritingTransaction().Result)
{
trOuter = db.StartWritingTransaction().AsTask();
tr.Commit();
}
using (var tr = trOuter.Result)
{
tr.Commit();
}
}
public void SimpleEraseCurrentWorks()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using var tr = db.StartTransaction();
tr.CreateKey(_key1);
tr.CreateKey(_key2);
tr.CreateKey(_key3);
tr.EraseCurrent();
Assert.True(tr.FindFirstKey(ReadOnlySpan <byte> .Empty));
Assert.Equal(_key1, tr.GetKey().ToArray());
Assert.True(tr.FindNextKey(ReadOnlySpan <byte> .Empty));
Assert.Equal(_key2, tr.GetKey().ToArray());
Assert.False(tr.FindNextKey(ReadOnlySpan <byte> .Empty));
Assert.Equal(2, tr.GetKeyValueCount());
}
public void FindLastKeyWorks()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartTransaction())
{
Assert.False(tr.FindLastKey());
tr.CreateKey(_key1);
tr.CreateKey(_key2);
tr.CreateKey(_key3);
Assert.True(tr.FindLastKey());
Assert.Equal(_key2, tr.GetKeyAsByteArray());
tr.Commit();
}
}
}
public void SimpleFindNextKeyWorks()
{
using IKeyValueDB db = new InMemoryKeyValueDB();
using (var tr1 = db.StartTransaction())
{
tr1.CreateKey(_key1);
tr1.CreateKey(_key2);
tr1.CreateKey(_key3);
tr1.Commit();
}
using (var tr2 = db.StartTransaction())
{
Assert.True(tr2.FindExactKey(_key3));
Assert.True(tr2.FindNextKey(ReadOnlySpan <byte> .Empty));
Assert.Equal(_key2, tr2.GetKey().ToArray());
Assert.False(tr2.FindNextKey(ReadOnlySpan <byte> .Empty));
}
}
public void MoreComplexTransaction()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartTransaction())
{
Assert.True(tr.CreateOrUpdateKeyValue(ByteBuffer.NewAsync(_key1), ByteBuffer.NewAsync(new byte[0])));
Assert.False(tr.CreateOrUpdateKeyValue(ByteBuffer.NewAsync(_key1), ByteBuffer.NewAsync(new byte[0])));
Assert.Equal(FindResult.Previous, tr.Find(ByteBuffer.NewAsync(_key2)));
Assert.True(tr.CreateOrUpdateKeyValue(ByteBuffer.NewAsync(_key2), ByteBuffer.NewAsync(new byte[0])));
Assert.Equal(FindResult.Exact, tr.Find(ByteBuffer.NewAsync(_key1)));
Assert.Equal(FindResult.Exact, tr.Find(ByteBuffer.NewAsync(_key2)));
Assert.Equal(FindResult.Previous, tr.Find(ByteBuffer.NewAsync(_key3)));
Assert.Equal(FindResult.Next, tr.Find(ByteBuffer.NewEmpty()));
tr.Commit();
}
}
}
public void SimpleEraseCurrentWorks()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartTransaction())
{
tr.CreateKey(_key1);
tr.CreateKey(_key2);
tr.CreateKey(_key3);
tr.EraseCurrent();
Assert.True(tr.FindFirstKey());
Assert.Equal(_key1, tr.GetKeyAsByteArray());
Assert.True(tr.FindNextKey());
Assert.Equal(_key2, tr.GetKeyAsByteArray());
Assert.False(tr.FindNextKey());
Assert.Equal(2, tr.GetKeyValueCount());
}
}
}
public void SimplePrefixWorks()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr = db.StartTransaction())
{
tr.CreateKey(_key1);
tr.CreateKey(_key2);
tr.CreateKey(_key3);
Assert.Equal(3, tr.GetKeyValueCount());
tr.SetKeyPrefix(ByteBuffer.NewAsync(_key1, 0, 3));
Assert.Equal(2, tr.GetKeyValueCount());
tr.FindFirstKey();
Assert.Equal(new byte[0], tr.GetKeyAsByteArray());
tr.FindLastKey();
Assert.Equal(_key3.Skip(3).ToArray(), tr.GetKeyAsByteArray());
tr.Commit();
}
}
}
public void SimpleFindPreviousKeyWorks()
{
using (IKeyValueDB db = new InMemoryKeyValueDB())
{
using (var tr1 = db.StartTransaction())
{
tr1.CreateKey(_key1);
tr1.CreateKey(_key2);
tr1.CreateKey(_key3);
tr1.Commit();
}
using (var tr2 = db.StartTransaction())
{
Assert.True(tr2.FindExactKey(_key3));
Assert.True(tr2.FindPreviousKey());
Assert.Equal(_key1, tr2.GetKeyAsByteArray());
Assert.False(tr2.FindPreviousKey());
}
}
}
