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()); } } }