public KeyValueDBValueWriter(IKeyValueDBTransaction transaction)
{
_transaction = transaction;
Buf = new byte[4096];
End = Buf.Length;
_ofs = 0;
}
/// <summary>
/// Reads and inserts all key value pairs into current prefix from stream
/// </summary>
/// <param name="transaction">transaction where to import all data</param>
/// <param name="stream">where to read it from</param>
public static void Import(IKeyValueDBTransaction transaction, Stream stream)
{
if (transaction == null) throw new ArgumentNullException(nameof(transaction));
if (stream == null) throw new ArgumentNullException(nameof(stream));
if (!stream.CanRead) throw new ArgumentException("stream must be readable", nameof(stream));
var tempbuf = new byte[4096];
var tempbuf2 = new byte[4096];
if (stream.Read(tempbuf, 0, 16) != 16) throw new EndOfStreamException();
if (tempbuf[0] != 'B' || tempbuf[1] != 'T' || tempbuf[2] != 'D' || tempbuf[3] != 'B' || tempbuf[4] != 'E' || tempbuf[5] != 'X' || tempbuf[6] != 'P' || tempbuf[7] != '2')
{
throw new BTDBException("Invalid header (it should Start with BTDBEXP2)");
}
var keyValuePairs = PackUnpack.UnpackInt64LE(tempbuf, 8);
if (keyValuePairs < 0) throw new BTDBException("Negative number of key value pairs");
for (var kv = 0; kv < keyValuePairs; kv++)
{
if (stream.Read(tempbuf, 0, 4) != 4) throw new EndOfStreamException();
var keySize = PackUnpack.UnpackInt32LE(tempbuf, 0);
if (keySize < 0) throw new BTDBException("Negative key size");
if (keySize > tempbuf.Length) tempbuf = new byte[keySize];
if (stream.Read(tempbuf, 0, keySize) != keySize) throw new EndOfStreamException();
if (stream.Read(tempbuf2, 0, 4) != 4) throw new EndOfStreamException();
var valueSize = PackUnpack.UnpackInt32LE(tempbuf2, 0);
if (valueSize < 0) throw new BTDBException("Negative value size");
if (valueSize > tempbuf2.Length) tempbuf2 = new byte[valueSize];
if (stream.Read(tempbuf2, 0, valueSize) != valueSize) throw new EndOfStreamException();
transaction.CreateOrUpdateKeyValue(ByteBuffer.NewSync(tempbuf,0,keySize),ByteBuffer.NewSync(tempbuf2,0,valueSize));
}
}
public KeyValueDBValueWriter(IKeyValueDBTransaction transaction)
{
_transaction = transaction;
Buf = new byte[4096];
End = Buf.Length;
_ofs = 0;
}
public ObjectDBTransaction(ObjectDB owner, IKeyValueDBTransaction keyValueTr, bool readOnly)
{
_owner = owner;
_keyValueTr = keyValueTr;
_readOnly = readOnly;
_transactionNumber = keyValueTr.GetTransactionNumber();
}
public RelationDBManipulator(IObjectDBTransaction transaction, RelationInfo relationInfo)
{
_transaction = (IInternalObjectDBTransaction)transaction;
_kvtr = _transaction.KeyValueDBTransaction;
_relationInfo = relationInfo;
_hasSecondaryIndexes = _relationInfo.ClientRelationVersionInfo.HasSecondaryIndexes;
}
/// <summary>
/// Writes all key value pairs in current prefix to stream (prefix itself is not written)
/// </summary>
/// <param name="transaction">transaction from where export all data</param>
/// <param name="stream">where to write it to</param>
public static void Export(IKeyValueDBTransaction transaction, Stream stream)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (!stream.CanWrite)
{
throw new ArgumentException("stream must be writeable", nameof(stream));
}
var keyValueCount = transaction.GetKeyValueCount();
var tempbuf = new byte[16];
tempbuf[0] = (byte)'B';
tempbuf[1] = (byte)'T';
tempbuf[2] = (byte)'D';
tempbuf[3] = (byte)'B';
tempbuf[4] = (byte)'E';
tempbuf[5] = (byte)'X';
tempbuf[6] = (byte)'P';
tempbuf[7] = (byte)'2';
PackUnpack.PackInt64LE(tempbuf, 8, keyValueCount);
stream.Write(tempbuf, 0, 16);
transaction.FindFirstKey(new ReadOnlySpan <byte>());
Span <byte> keyBuffer = stackalloc byte[256];
for (long kv = 0; kv < keyValueCount; kv++)
{
var key = transaction.GetKey(ref MemoryMarshal.GetReference(keyBuffer), keyBuffer.Length);
PackUnpack.PackInt32LE(tempbuf, 0, key.Length);
stream.Write(tempbuf, 0, 4);
stream.Write(key);
var value = transaction.GetValue();
PackUnpack.PackInt32LE(tempbuf, 0, value.Length);
stream.Write(tempbuf, 0, 4);
stream.Write(value);
transaction.FindNextKey(new ReadOnlySpan <byte>());
}
var ulongCount = transaction.GetUlongCount();
if (transaction.GetCommitUlong() != 0 || ulongCount != 0)
{
PackUnpack.PackUInt64LE(tempbuf, 0, transaction.GetCommitUlong());
stream.Write(tempbuf, 0, 8);
}
if (ulongCount != 0)
{
PackUnpack.PackUInt32LE(tempbuf, 0, ulongCount);
stream.Write(tempbuf, 0, 4);
for (var i = 0u; i < ulongCount; i++)
{
PackUnpack.PackUInt64LE(tempbuf, 0, transaction.GetUlong(i));
stream.Write(tempbuf, 0, 8);
}
}
}
void LoadVersionInfos(IKeyValueDBTransaction tr)
{
LastPersistedVersion = 0;
var writer = new ByteBufferWriter();
writer.WriteByteArrayRaw(ObjectDB.RelationVersionsPrefix);
writer.WriteVUInt32(_id);
tr.SetKeyPrefix(writer.Data);
if (!tr.FindFirstKey())
{
return;
}
var keyReader = new KeyValueDBKeyReader(tr);
var valueReader = new KeyValueDBValueReader(tr);
do
{
keyReader.Restart();
valueReader.Restart();
LastPersistedVersion = keyReader.ReadVUInt32();
var relationVersionInfo = RelationVersionInfo.Load(valueReader,
_relationInfoResolver.FieldHandlerFactory, _name);
_relationVersions[LastPersistedVersion] = relationVersionInfo;
} while (tr.FindNextKey());
}
public RelationAdvancedEnumerator(
IRelationDbManipulator manipulator, ByteBuffer prefixBytes, uint prefixFieldCount, int loaderIndex)
{
_prefixFieldCount = prefixFieldCount;
_manipulator = manipulator;
ItemLoader = _manipulator.RelationInfo.ItemLoaderInfos[loaderIndex];
_ascending = true;
_tr = manipulator.Transaction;
_keyValueTr = _tr.KeyValueDBTransaction;
_keyValueTrProtector = _tr.TransactionProtector;
_prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
_keyBytes = prefixBytes;
_keyValueTrProtector.Start();
_keyValueTr.SetKeyPrefix(_keyBytes);
_prevModificationCounter = manipulator.ModificationCounter.ModificationCounter;
_count = (uint)_keyValueTr.GetKeyValueCount();
_startPos = _ascending ? 0 : _count - 1;
_pos = 0;
_seekNeeded = true;
_lengthOfNonDataPrefix = manipulator.RelationInfo.Prefix.Length;
}
/// <summary>
/// Writes all key value pairs in current prefix to stream (prefix itself is not written)
/// </summary>
/// <param name="transaction">transaction from where export all data</param>
/// <param name="stream">where to write it to</param>
public static void Export(IKeyValueDBTransaction transaction, Stream stream)
{
if (transaction == null) throw new ArgumentNullException(nameof(transaction));
if (stream == null) throw new ArgumentNullException(nameof(stream));
if (!stream.CanWrite) throw new ArgumentException("stream must be writeable", nameof(stream));
var keyValueCount = transaction.GetKeyValueCount();
var tempbuf = new byte[16];
tempbuf[0] = (byte)'B';
tempbuf[1] = (byte)'T';
tempbuf[2] = (byte)'D';
tempbuf[3] = (byte)'B';
tempbuf[4] = (byte)'E';
tempbuf[5] = (byte)'X';
tempbuf[6] = (byte)'P';
tempbuf[7] = (byte)'2';
PackUnpack.PackInt64LE(tempbuf, 8, keyValueCount);
stream.Write(tempbuf, 0, 16);
transaction.FindFirstKey();
for (long kv = 0; kv < keyValueCount; kv++)
{
var key = transaction.GetKey();
PackUnpack.PackInt32LE(tempbuf, 0, key.Length);
stream.Write(tempbuf, 0, 4);
stream.Write(key.Buffer, key.Offset, key.Length);
var value = transaction.GetValue();
PackUnpack.PackInt32LE(tempbuf, 0, value.Length);
stream.Write(tempbuf, 0, 4);
stream.Write(value.Buffer, value.Offset, value.Length);
transaction.FindNextKey();
}
}
/// <summary>
/// Writes all key value pairs in current prefix to stream (prefix itself is not written)
/// </summary>
/// <param name="transaction">transaction from where export all data</param>
/// <param name="stream">where to write it to</param>
public static void Export(IKeyValueDBTransaction transaction, Stream stream)
{
if (transaction == null)
{
throw new ArgumentNullException("transaction");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (!stream.CanWrite)
{
throw new ArgumentException("stream must be writeable", "stream");
}
var keyValueCount = transaction.GetKeyValueCount();
var tempbuf = new byte[16];
tempbuf[0] = (byte)'B';
tempbuf[1] = (byte)'T';
tempbuf[2] = (byte)'D';
tempbuf[3] = (byte)'B';
tempbuf[4] = (byte)'E';
tempbuf[5] = (byte)'X';
tempbuf[6] = (byte)'P';
tempbuf[7] = (byte)'1';
PackUnpack.PackInt64LE(tempbuf, 8, keyValueCount);
stream.Write(tempbuf, 0, 16);
transaction.FindFirstKey();
for (long kv = 0; kv < keyValueCount; kv++)
{
var keySize = transaction.GetKeySize();
PackUnpack.PackInt32LE(tempbuf, 0, keySize);
stream.Write(tempbuf, 0, 4);
long ofs = 0;
while (ofs < keySize)
{
int len;
byte[] buf;
int bufOfs;
transaction.PeekKey((int)ofs, out len, out buf, out bufOfs);
stream.Write(buf, bufOfs, len);
ofs += len;
}
var valueSize = transaction.GetValueSize();
PackUnpack.PackInt64LE(tempbuf, 0, valueSize);
stream.Write(tempbuf, 0, 8);
ofs = 0;
while (ofs < valueSize)
{
int len;
byte[] buf;
int bufOfs;
transaction.PeekValue(ofs, out len, out buf, out bufOfs);
stream.Write(buf, bufOfs, len);
ofs += len;
}
transaction.FindNextKey();
}
}
internal static IEnumerable <KeyValuePair <uint, string> > LoadTablesEnum(IKeyValueDBTransaction tr)
{
tr.InvalidateCurrentKey();
while (tr.FindNextKey(TableNamesPrefix))
{
yield return(new KeyValuePair <uint, string>((uint)PackUnpack.UnpackVUInt(tr.GetKey().Slice(TableNamesPrefixLen)), new SpanReader(tr.GetValue()).ReadString()));
}
}
public static bool CreateKey(this IKeyValueDBTransaction transaction, byte[] keyBuf)
{
if (FindExactKey(transaction, keyBuf))
{
return(false);
}
return(transaction.CreateOrUpdateKeyValue(ByteBuffer.NewSync(keyBuf), ByteBuffer.NewEmpty()));
}
public void MarkCurrentKeyAsUsed(IKeyValueDBTransaction tr)
{
Keys = Keys.ResizingAppend(ByteBuffer.NewAsync(tr.GetKey()));
Builder.Append("Used key: ");
Print(tr.GetKey());
Builder.AppendFormat(" Value len:{0}", tr.GetStorageSizeOfCurrentKey().Value);
Builder.AppendLine();
}
void MarkKeyAsUsed(IKeyValueDBTransaction tr)
{
_kvtr.SetKeyPrefix(tr.GetKeyPrefix());
if (_kvtr.Find(tr.GetKey()) == FindResult.Exact)
{
_kvtr.EraseCurrent();
}
}
public void Dispose()
{
if (_keyValueTr == null)
{
return;
}
_keyValueTr.Dispose();
_keyValueTr = null;
}
internal void CommitLastObjIdAndDictId(ulong newLastDictId, IKeyValueDBTransaction tr)
{
tr.SetUlong(0, (ulong)_lastObjId);
if (_lastDictId != newLastDictId)
{
tr.SetUlong(1, newLastDictId);
_lastDictId = newLastDictId;
}
}
public void Iterate(IObjectDBTransaction tr)
{
var iterator = new ODBIterator(tr, new VisitorForFindUnused(this));
using (_kvtr = _keyValueDb.StartWritingTransaction().Result)
{
iterator.Iterate();
_kvtr.Commit();
}
_kvtr = null;
}
public void MarkCurrentKeyAsUsed(IKeyValueDBTransaction tr)
{
Keys = Keys.ResizingAppend(ByteBuffer.NewSync(tr.GetKeyPrefix())).ResizingAppend(tr.GetKey());
Builder.Append("Used key: ");
Print(ByteBuffer.NewSync(tr.GetKeyPrefix()));
Builder.Append('|');
Print(tr.GetKey());
Builder.AppendFormat(" Value len:{0}", tr.GetStorageSizeOfCurrentKey().Value);
Builder.AppendLine();
}
internal void CommitLastDictId(ulong newLastDictId, IKeyValueDBTransaction tr)
{
if (_lastDictId != newLastDictId)
{
tr.SetKeyPrefix(null);
var w = new ByteBufferWriter();
w.WriteVUInt64(newLastDictId);
tr.CreateOrUpdateKeyValue(LastDictIdKey, w.Data.ToByteArray());
_lastDictId = newLastDictId;
}
}
public void Iterate(IObjectDBTransaction tr)
{
var iterator = new ODBIterator(tr, new VisitorForFindUnused(this));
using (_kvtr = _keyValueDb.StartWritingTransaction().Result)
{
iterator.Iterate();
_kvtr.Commit();
}
_kvtr = null;
}
internal void CommitLastDictId(ulong newLastDictId, IKeyValueDBTransaction tr)
{
if (_lastDictId != newLastDictId)
{
tr.SetKeyPrefix(null);
var w = new ByteBufferWriter();
w.WriteVUInt64(newLastDictId);
tr.CreateOrUpdateKeyValue(LastDictIdKey, w.Data.ToByteArray());
_lastDictId = newLastDictId;
}
}
static IEnumerable <string> LoadTablesEnum(IKeyValueDBTransaction tr)
{
tr.SetKeyPrefix(TableNamesPrefix);
var valueReader = new KeyValueDBValueReader(tr);
while (tr.Enumerate())
{
valueReader.Restart();
yield return(valueReader.ReadString());
}
}
void DeleteSecondaryKey(IKeyValueDBTransaction keyValueTr, uint prevIdx)
{
var writer = new ByteBufferWriter();
writer.WriteBlock(ObjectDB.AllRelationsSKPrefix);
writer.WriteVUInt32(Id);
writer.WriteVUInt32(prevIdx);
keyValueTr.SetKeyPrefix(writer.Data);
keyValueTr.EraseAll();
}
internal static IEnumerable<KeyValuePair<uint, string>> LoadTablesEnum(IKeyValueDBTransaction tr)
{
tr.SetKeyPrefixUnsafe(TableNamesPrefix);
var keyReader = new KeyValueDBKeyReader(tr);
var valueReader = new KeyValueDBValueReader(tr);
while (tr.FindNextKey())
{
keyReader.Restart();
valueReader.Restart();
yield return new KeyValuePair<uint, string>(keyReader.ReadVUInt32(), valueReader.ReadString());
}
}
public static byte[] ReadKey(this IKeyValueDBTransaction transaction)
{
int keySize = transaction.GetKeySize();
if (keySize < 0)
{
return(null);
}
var result = new byte[keySize];
transaction.ReadKey(0, keySize, result, 0);
return(result);
}
public static bool Enumerate(this IKeyValueDBTransaction transaction)
{
if (transaction.GetKeyIndex() < 0)
{
return(transaction.FindFirstKey());
}
if (transaction.FindNextKey())
{
return(true);
}
transaction.InvalidateCurrentKey();
return(false);
}
internal static IEnumerable <KeyValuePair <uint, string> > LoadTablesEnum(IKeyValueDBTransaction tr)
{
tr.SetKeyPrefixUnsafe(TableNamesPrefix);
var keyReader = new KeyValueDBKeyReader(tr);
var valueReader = new KeyValueDBValueReader(tr);
while (tr.FindNextKey())
{
keyReader.Restart();
valueReader.Restart();
yield return(new KeyValuePair <uint, string>(keyReader.ReadVUInt32(), valueReader.ReadString()));
}
}
public ODBIterator(IObjectDBTransaction tr, IODBFastVisitor visitor)
{
_tr = (IInternalObjectDBTransaction)tr;
_trkv = _tr.KeyValueDBTransaction;
_fastVisitor = visitor;
_visitor = visitor as IODBVisitor;
_usedTableIds = new HashSet <uint>();
_visitedOids = new HashSet <ulong>();
_usedTableVersions = new HashSet <TableIdVersion>();
_tableVersionInfos = new Dictionary <TableIdVersion, TableVersionInfo>();
_skippers = new Dictionary <IFieldHandler, Action <AbstractBufferedReader> >(ReferenceEqualityComparer <IFieldHandler> .Instance);
_loaders = new Dictionary <IFieldHandler, Func <AbstractBufferedReader, object> >(ReferenceEqualityComparer <IFieldHandler> .Instance);
}
/// <summary>
/// Writes all key value pairs in current prefix to stream (prefix itself is not written)
/// </summary>
/// <param name="transaction">transaction from where export all data</param>
/// <param name="stream">where to write it to</param>
public static void Export(IKeyValueDBTransaction transaction, Stream stream)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (stream == null) throw new ArgumentNullException("stream");
if (!stream.CanWrite) throw new ArgumentException("stream must be writeable", "stream");
var keyValueCount = transaction.GetKeyValueCount();
var tempbuf = new byte[16];
tempbuf[0] = (byte)'B';
tempbuf[1] = (byte)'T';
tempbuf[2] = (byte)'D';
tempbuf[3] = (byte)'B';
tempbuf[4] = (byte)'E';
tempbuf[5] = (byte)'X';
tempbuf[6] = (byte)'P';
tempbuf[7] = (byte)'1';
PackUnpack.PackInt64LE(tempbuf, 8, keyValueCount);
stream.Write(tempbuf, 0, 16);
transaction.FindFirstKey();
for (long kv = 0; kv < keyValueCount; kv++)
{
var keySize = transaction.GetKeySize();
PackUnpack.PackInt32LE(tempbuf, 0, keySize);
stream.Write(tempbuf, 0, 4);
long ofs = 0;
while (ofs < keySize)
{
int len;
byte[] buf;
int bufOfs;
transaction.PeekKey((int)ofs, out len, out buf, out bufOfs);
stream.Write(buf, bufOfs, len);
ofs += len;
}
var valueSize = transaction.GetValueSize();
PackUnpack.PackInt64LE(tempbuf, 0, valueSize);
stream.Write(tempbuf, 0, 8);
ofs = 0;
while (ofs < valueSize)
{
int len;
byte[] buf;
int bufOfs;
transaction.PeekValue(ofs, out len, out buf, out bufOfs);
stream.Write(buf, bufOfs, len);
ofs += len;
}
transaction.FindNextKey();
}
}
public ODBDictionary(IInternalObjectDBTransaction tr, ODBDictionaryConfiguration config, ulong id)
{
_tr = tr;
_keyHandler = config.KeyHandler;
_valueHandler = config.ValueHandler;
_id = id;
GeneratePrefix();
_keyReader = (Func <AbstractBufferedReader, IReaderCtx, TKey>)config.KeyReader;
_keyWriter = (Action <TKey, AbstractBufferedWriter, IWriterCtx>)config.KeyWriter;
_valueReader = (Func <AbstractBufferedReader, IReaderCtx, TValue>)config.ValueReader;
_valueWriter = (Action <TValue, AbstractBufferedWriter, IWriterCtx>)config.ValueWriter;
_keyValueTr = _tr.KeyValueDBTransaction;
_keyValueTrProtector = _tr.TransactionProtector;
_count = -1;
}
public RelationEnumerator(IInternalObjectDBTransaction tr, RelationInfo relationInfo, byte[] keyBytes,
IRelationModificationCounter modificationCounter, int loaderIndex)
{
_transaction = tr;
ItemLoader = relationInfo.ItemLoaderInfos[loaderIndex];
_keyValueTr = _transaction.KeyValueDBTransaction;
_prevProtectionCounter = _keyValueTr.CursorMovedCounter;
KeyBytes = keyBytes;
_modificationCounter = modificationCounter;
_pos = 0;
_seekNeeded = true;
_prevModificationCounter = _modificationCounter.ModificationCounter;
}
public RelationEnumerator(IInternalObjectDBTransaction tr, RelationInfo relationInfo, ByteBuffer keyBytes)
{
RelationInfo = relationInfo;
_tr = tr;
_keyValueTr = _tr.KeyValueDBTransaction;
_keyValueTrProtector = _tr.TransactionProtector;
_prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
KeyBytes = keyBytes;
_keyValueTr.SetKeyPrefix(KeyBytes);
_pos = 0;
_seekNeeded = true;
_prevModificationCounter = relationInfo.ModificationCounter;
}
public ODBSet(IInternalObjectDBTransaction tr, ODBDictionaryConfiguration config, ulong id)
{
_tr = tr;
_keyHandler = config.KeyHandler;
_id = id;
var o = ObjectDB.AllDictionariesPrefix.Length;
_prefix = new byte[o + PackUnpack.LengthVUInt(_id)];
Array.Copy(ObjectDB.AllDictionariesPrefix, _prefix, o);
PackUnpack.PackVUInt(_prefix, ref o, _id);
_keyReader = ((Func <AbstractBufferedReader, IReaderCtx, TKey>)config.KeyReader) !;
_keyWriter = ((Action <TKey, AbstractBufferedWriter, IWriterCtx>)config.KeyWriter) !;
_keyValueTr = _tr.KeyValueDBTransaction;
_keyValueTrProtector = _tr.TransactionProtector;
_count = -1;
}
internal void CommitLastObjIdAndDictId(IKeyValueDBTransaction tr)
{
var lastOid = GetLastAllocatedOid();
if (tr.GetUlong(0) < lastOid)
{
tr.SetUlong(0, lastOid);
}
var lastDistId = GetLastAllocatedDictId();
if (tr.GetUlong(1) < lastDistId)
{
tr.SetUlong(1, lastDistId);
}
}
void ImportKeysWithPrefix(byte[] prefix, IKeyValueDBTransaction sourceKvTr)
{
sourceKvTr.SetKeyPrefix(prefix);
if (!sourceKvTr.FindFirstKey())
return;
using (var kvtr = _keyValueDb.StartWritingTransaction().Result)
{
kvtr.SetKeyPrefix(prefix);
do
{
//create all keys, instead of value store only byte length of value
kvtr.CreateOrUpdateKeyValue(sourceKvTr.GetKey(), Vuint2ByteBuffer(sourceKvTr.GetStorageSizeOfCurrentKey().Value));
} while (sourceKvTr.FindNextKey());
kvtr.Commit();
}
}
internal static ByteBuffer FindLastKeyWithPrefix(ByteBuffer keyBytes, ByteBuffer endKeyBytes,
IKeyValueDBTransaction keyValueTr, KeyValueDBTransactionProtector keyValueTrProtector)
{
var buffer = ByteBuffer.NewEmpty();
buffer = buffer.ResizingAppend(keyBytes).ResizingAppend(endKeyBytes);
keyValueTrProtector.Start();
keyValueTr.SetKeyPrefix(buffer);
if (!keyValueTr.FindLastKey())
{
return(endKeyBytes);
}
var key = keyValueTr.GetKeyIncludingPrefix();
return(key.Slice(keyBytes.Length));
}
// ReSharper disable once MemberCanBePrivate.Global used by FieldHandler.Load
public ODBSet(IInternalObjectDBTransaction tr, ODBDictionaryConfiguration config, ulong id)
{
_tr = tr;
_keyHandler = config.KeyHandler;
_id = id;
var len = PackUnpack.LengthVUInt(id);
var prefix = new byte[ObjectDB.AllDictionariesPrefixLen + len];
MemoryMarshal.GetReference(prefix.AsSpan()) = ObjectDB.AllDictionariesPrefixByte;
PackUnpack.UnsafePackVUInt(ref Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(prefix.AsSpan()), (IntPtr)ObjectDB.AllDictionariesPrefixLen), id, len);
_prefix = prefix;
_keyReader = ((ReaderFun <TKey>)config.KeyReader) !;
_keyWriter = ((WriterFun <TKey>)config.KeyWriter) !;
_keyValueTr = _tr.KeyValueDBTransaction;
_count = -1;
}
void ImportKeysWithPrefix(byte[] prefix, IKeyValueDBTransaction sourceKvTr)
{
if (!sourceKvTr.FindFirstKey(prefix))
{
return;
}
using (var kvtr = _keyValueDb.StartWritingTransaction().Result)
{
do
{
//create all keys, instead of value store only byte length of value
kvtr.CreateOrUpdateKeyValue(sourceKvTr.GetKey(), Vuint2ByteBuffer(sourceKvTr.GetStorageSizeOfCurrentKey().Value));
} while (sourceKvTr.FindNextKey(prefix));
kvtr.Commit();
}
}
/// <summary>
/// Writes all key value pairs in current prefix to stream (prefix itself is not written)
/// </summary>
/// <param name="transaction">transaction from where export all data</param>
/// <param name="stream">where to write it to</param>
public static void Export(IKeyValueDBTransaction transaction, Stream stream)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (!stream.CanWrite)
{
throw new ArgumentException("stream must be writeable", nameof(stream));
}
var keyValueCount = transaction.GetKeyValueCount();
var tempbuf = new byte[16];
tempbuf[0] = (byte)'B';
tempbuf[1] = (byte)'T';
tempbuf[2] = (byte)'D';
tempbuf[3] = (byte)'B';
tempbuf[4] = (byte)'E';
tempbuf[5] = (byte)'X';
tempbuf[6] = (byte)'P';
tempbuf[7] = (byte)'2';
PackUnpack.PackInt64LE(tempbuf, 8, keyValueCount);
stream.Write(tempbuf, 0, 16);
transaction.FindFirstKey();
for (long kv = 0; kv < keyValueCount; kv++)
{
var key = transaction.GetKey();
PackUnpack.PackInt32LE(tempbuf, 0, key.Length);
stream.Write(tempbuf, 0, 4);
stream.Write(key.Buffer, key.Offset, key.Length);
var value = transaction.GetValue();
PackUnpack.PackInt32LE(tempbuf, 0, value.Length);
stream.Write(tempbuf, 0, 4);
stream.Write(value.Buffer, value.Offset, value.Length);
transaction.FindNextKey();
}
if (transaction.GetCommitUlong() != 0)
{
PackUnpack.PackUInt64LE(tempbuf, 0, transaction.GetCommitUlong());
stream.Write(tempbuf, 0, 8);
}
}
/// <summary>
/// Reads and inserts all key value pairs into current prefix from stream
/// </summary>
/// <param name="transaction">transaction where to import all data</param>
/// <param name="stream">where to read it from</param>
public static void Import(IKeyValueDBTransaction transaction, Stream stream)
{
if (transaction == null) throw new ArgumentNullException("transaction");
if (stream == null) throw new ArgumentNullException("stream");
if (!stream.CanRead) throw new ArgumentException("stream must be readable", "stream");
var tempbuf = new byte[4096];
if (stream.Read(tempbuf, 0, 16) != 16) throw new EndOfStreamException();
if (tempbuf[0] != 'B' || tempbuf[1] != 'T' || tempbuf[2] != 'D' || tempbuf[3] != 'B' || tempbuf[4] != 'E' || tempbuf[5] != 'X' || tempbuf[6] != 'P' || tempbuf[7] != '1')
{
throw new BTDBException("Invalid header (it should start with BTDBEXP1)");
}
var keyValuePairs = PackUnpack.UnpackInt64LE(tempbuf, 8);
if (keyValuePairs < 0) throw new BTDBException("Negative number of key value pairs");
for (var kv = 0; kv < keyValuePairs; kv++)
{
if (stream.Read(tempbuf, 0, 4) != 4) throw new EndOfStreamException();
var keySize = PackUnpack.UnpackInt32LE(tempbuf, 0);
if (keySize < 0) throw new BTDBException("Negative key size");
if (keySize > tempbuf.Length) tempbuf = new byte[keySize];
if (stream.Read(tempbuf, 0, keySize) != keySize) throw new EndOfStreamException();
transaction.CreateKey(tempbuf);
if (stream.Read(tempbuf, 0, 8) != 8) throw new EndOfStreamException();
var valueSize = PackUnpack.UnpackInt64LE(tempbuf, 0);
if (valueSize < 0) throw new BTDBException("Negative value size");
if (valueSize <= tempbuf.Length)
{
if (stream.Read(tempbuf, 0, (int)valueSize) != valueSize) throw new EndOfStreamException();
transaction.SetValue(tempbuf, 0, (int)valueSize);
}
else
{
transaction.SetValueSize(valueSize);
long pos = 0;
while (pos < valueSize)
{
int toRead = (int)Math.Min(valueSize - pos, tempbuf.Length);
if (stream.Read(tempbuf, 0, toRead) != toRead) throw new EndOfStreamException();
transaction.WriteValue(pos,toRead,tempbuf,0);
pos += toRead;
}
}
}
}
static IEnumerable<string> LoadTablesEnum(IKeyValueDBTransaction tr)
{
tr.SetKeyPrefix(TableNamesPrefix);
var valueReader = new KeyValueDBValueReader(tr);
while (tr.Enumerate())
{
valueReader.Restart();
yield return valueReader.ReadString();
}
}
internal KeyValueDBValueProtectedWriter(IKeyValueDBTransaction transaction, KeyValueDBTransactionProtector protector)
: base(transaction)
{
_protector = protector;
}
public KeyValueDBReplayTransactionProxy(IKeyValueDBTransaction tr, AbstractBufferedWriter log, ref int trCounter)
{
_tr = tr;
_log = log;
_trIndex = (uint)System.Threading.Interlocked.Increment(ref trCounter);
}
public void ReportTransactionLeak(IKeyValueDBTransaction transaction)
{
Leaked = transaction;
}
public KeyValueDBValueReader(IKeyValueDBTransaction transaction)
{
_transaction = transaction;
Restart();
}
void MarkKeyAsUsed(IKeyValueDBTransaction tr)
{
_kvtr.SetKeyPrefix(tr.GetKeyPrefix());
if (_kvtr.Find(tr.GetKey())==FindResult.Exact) _kvtr.EraseCurrent();
}
public void MarkCurrentKeyAsUsed(IKeyValueDBTransaction tr)
{
_finder.MarkKeyAsUsed(tr);
}
public KeyValueDBValueWriter(IKeyValueDBTransaction transaction)
{
_transaction = transaction;
}
public KeyValueDBValueReader(IKeyValueDBTransaction transaction):base(transaction.GetValue())
{
_transaction = transaction;
}
public void MarkCurrentKeyAsUsed(IKeyValueDBTransaction tr)
{
}
public KeyValueDBKeyReader(IKeyValueDBTransaction transaction)
: base(transaction.GetKey())
{
_transaction = transaction;
}
