public void Iterate(bool sortTableByNameAsc = false)
{
LoadTableNamesDict();
LoadRelationNamesDict();
MarkLastDictId();
_trkv.SetKeyPrefixUnsafe(ObjectDB.TableSingletonsPrefix);
var keyReader = new KeyValueDBKeyReader(_trkv);
var valueReader = new KeyValueDBValueReader(_trkv);
_singletons = new Dictionary <uint, ulong>();
while (_trkv.FindNextKey())
{
keyReader.Restart();
valueReader.Restart();
_singletons.Add(keyReader.ReadVUInt32(), valueReader.ReadVUInt64());
}
if (sortTableByNameAsc)
{
_singletons = _singletons.OrderBy(item =>
{
string name;
return(_tableId2Name.TryGetValue(item.Key, out name) ? name : string.Empty);
}).ToDictionary(item => item.Key, item => item.Value);
}
foreach (var singleton in _singletons)
{
string name;
if (_visitor != null &&
!_visitor.VisitSingleton(singleton.Key,
_tableId2Name.TryGetValue(singleton.Key, out name) ? name : null, singleton.Value))
{
continue;
}
MarkTableName(singleton.Key);
_trkv.SetKeyPrefixUnsafe(ObjectDB.TableSingletonsPrefix);
if (_trkv.Find(Vuint2ByteBuffer(singleton.Key)) == FindResult.Exact)
{
_fastVisitor.MarkCurrentKeyAsUsed(_trkv);
}
IterateOid(singleton.Value);
}
foreach (var relation in _relationId2Name)
{
if (_visitor != null && !_visitor.StartRelation(relation.Value))
{
continue;
}
MarkRelationName(relation.Key);
IterateRelation(relation.Key, relation.Value);
if (_visitor != null)
{
_visitor.EndRelation();
}
}
}
public IEnumerator <TKey> GetEnumerator()
{
long prevProtectionCounter = 0;
var prevModificationCounter = 0;
long pos = 0;
while (true)
{
_keyValueTrProtector.Start();
if (pos == 0)
{
prevModificationCounter = _modificationCounter;
_keyValueTr.SetKeyPrefix(_prefix);
if (!_keyValueTr.FindFirstKey())
{
break;
}
}
else
{
if (_keyValueTrProtector.WasInterupted(prevProtectionCounter))
{
if (prevModificationCounter != _modificationCounter)
{
ThrowModifiedDuringEnum();
}
_keyValueTr.SetKeyPrefix(_prefix);
if (!_keyValueTr.SetKeyIndex(pos))
{
break;
}
}
else
{
if (!_keyValueTr.FindNextKey())
{
break;
}
}
}
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
var keyBytes = _keyValueTr.GetKey();
var key = ByteArrayToKey(keyBytes);
yield return(key);
pos++;
}
}
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 bool MoveNext()
{
if (!_seekNeeded)
{
_pos++;
}
if (_pos >= _count)
{
return(false);
}
_keyValueTrProtector.Start();
if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter))
{
_manipulator.CheckModifiedDuringEnum(_prevModificationCounter);
_keyValueTr.SetKeyPrefix(_keyBytes);
Seek();
}
else if (_seekNeeded)
{
Seek();
}
else
{
if (_ascending)
{
_keyValueTr.FindNextKey();
}
else
{
_keyValueTr.FindPreviousKey();
}
}
_prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
return(true);
}
/// <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(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);
}
}
}
/// <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 void LoadGlobalInfo(bool sortTableByNameAsc = false)
{
LoadTableNamesDict();
LoadRelationInfoDict();
MarkLastDictId();
_trkv.InvalidateCurrentKey();
_singletons = new Dictionary <uint, ulong>();
while (_trkv.FindNextKey(ObjectDB.TableSingletonsPrefix))
{
_singletons.Add(new SpanReader(_trkv.GetKey().Slice((int)ObjectDB.TableSingletonsPrefixLen)).ReadVUInt32(), new SpanReader(_trkv.GetValue()).ReadVUInt64());
}
if (sortTableByNameAsc)
{
_singletons = _singletons.OrderBy(item => _tableId2Name.TryGetValue(item.Key, out var name) ? name : "").ToDictionary(item => item.Key, item => item.Value);
}
}
internal static IEnumerable <KeyValuePair <uint, string> > LoadRelationNamesEnum(IKeyValueDBTransaction tr)
{
tr.InvalidateCurrentKey();
while (tr.FindNextKey(RelationNamesPrefix))
{
yield return(new KeyValuePair <uint, string>((uint)PackUnpack.UnpackVUInt(tr.GetValue()), new SpanReader(tr.GetKey().Slice(RelationNamesPrefixLen)).ReadString()));
}
}
public IEnumerator <TKey> GetEnumerator()
{
long prevProtectionCounter = 0;
var prevModificationCounter = 0;
long pos = 0;
while (true)
{
if (pos == 0)
{
prevModificationCounter = _modificationCounter;
if (!_keyValueTr.FindFirstKey(_prefix))
{
break;
}
}
else
{
if (_keyValueTr.CursorMovedCounter != prevProtectionCounter)
{
if (prevModificationCounter != _modificationCounter)
{
ThrowModifiedDuringEnum();
}
if (!_keyValueTr.SetKeyIndex(_prefix, pos))
{
break;
}
}
else
{
if (!_keyValueTr.FindNextKey(_prefix))
{
break;
}
}
}
prevProtectionCounter = _keyValueTr.CursorMovedCounter;
var key = CurrentToKey();
yield return(key);
pos++;
}
}
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());
}
}
internal static IEnumerable <KeyValuePair <uint, string> > LoadRelationNamesEnum(IKeyValueDBTransaction tr)
{
tr.SetKeyPrefixUnsafe(RelationNamesPrefix);
var keyReader = new KeyValueDBKeyReader(tr);
var valueReader = new KeyValueDBValueReader(tr);
while (tr.FindNextKey())
{
keyReader.Restart();
valueReader.Restart();
yield return(new KeyValuePair <uint, string>(valueReader.ReadVUInt32(), keyReader.ReadString()));
}
}
public static bool Enumerate(this IKeyValueDBTransaction transaction)
{
if (transaction.GetKeyIndex() < 0)
{
return(transaction.FindFirstKey());
}
if (transaction.FindNextKey())
{
return(true);
}
transaction.InvalidateCurrentKey();
return(false);
}
/// <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();
}
}
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();
}
}
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();
}
}
/// <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);
}
}
public bool NextKey(out TKey key)
{
if (_seekState == SeekState.Ready)
{
_pos++;
}
if (_pos >= _count)
{
key = default(TKey);
return(false);
}
_keyValueTrProtector.Start();
if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter))
{
_keyValueTr.SetKeyPrefix(_keyBytes);
Seek();
}
else if (_seekState != SeekState.Ready)
{
Seek();
}
else
{
if (_ascending)
{
_keyValueTr.FindNextKey();
}
else
{
_keyValueTr.FindPreviousKey();
}
}
_prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
//read key
var keyData = _keyValueTr.GetKeyAsByteArray();
var reader = new ByteArrayReader(keyData);
key = _keyReader(reader, null);
return(true);
}
public bool MoveNext()
{
if (_seekState == SeekState.Ready)
{
_pos++;
}
if (_pos >= _count)
{
Current = default;
return(false);
}
_keyValueTrProtector.Start();
if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter))
{
if (_prevModificationCounter != _owner._modificationCounter)
{
ThrowModifiedDuringEnum();
}
_keyValueTr.SetKeyPrefix(_owner._prefix);
Seek();
}
else if (_seekState != SeekState.Ready)
{
Seek();
}
else
{
if (_ascending)
{
_keyValueTr.FindNextKey();
}
else
{
_keyValueTr.FindPreviousKey();
}
}
_prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
Current = _owner.ByteArrayToKey(_keyValueTr.GetKey());
return(true);
}
public bool MoveNext()
{
if (_seekState == SeekState.Ready)
{
_pos++;
}
if (_pos >= _count)
{
Current = default;
return(false);
}
if (_keyValueTr.CursorMovedCounter != _prevProtectionCounter)
{
if (_prevModificationCounter != _owner._modificationCounter)
{
ThrowModifiedDuringEnum();
}
Seek();
}
else if (_seekState != SeekState.Ready)
{
Seek();
}
else
{
if (_ascending)
{
_keyValueTr.FindNextKey(_owner._prefix);
}
else
{
_keyValueTr.FindPreviousKey(_owner._prefix);
}
}
_prevProtectionCounter = _keyValueTr.CursorMovedCounter;
Current = _owner.CurrentToKey();
return(true);
}
//secKeyBytes contains already AllRelationsSKPrefix
public T FindBySecondaryKeyOrDefault(uint secondaryKeyIndex, uint prefixParametersCount, ByteBuffer secKeyBytes,
bool throwWhenNotFound)
{
_transaction.TransactionProtector.Start();
_kvtr.SetKeyPrefix(secKeyBytes);
if (!_kvtr.FindFirstKey())
{
if (throwWhenNotFound)
{
throw new BTDBException("Not found.");
}
return(default(T));
}
var keyBytes = _kvtr.GetKey();
if (_kvtr.FindNextKey())
{
throw new BTDBException("Ambiguous result.");
}
return(CreateInstanceFromSK(secondaryKeyIndex, prefixParametersCount, secKeyBytes, keyBytes));
}
public bool NextKey(out TKey key)
{
if (!_seekNeeded)
{
_pos++;
}
if (_pos >= _count)
{
key = default(TKey);
return(false);
}
_keyValueTrProtector.Start();
if (_keyValueTrProtector.WasInterupted(_prevProtectionCounter))
{
if (_prevModificationCounter != _owner._modificationCounter)
{
ThrowModifiedDuringEnum();
}
_keyValueTr.SetKeyPrefix(_owner._prefix);
Seek();
}
else if (_seekNeeded)
{
Seek();
}
else
{
if (_ascending)
{
_keyValueTr.FindNextKey();
}
else
{
_keyValueTr.FindPreviousKey();
}
}
key = _owner.ByteArrayToKey(_keyValueTr.GetKeyAsByteArray());
return(true);
}
public IEnumerable <object> Enumerate(Type type)
{
if (type == typeof(object))
{
type = null;
}
else if (type != null)
{
AutoRegisterType(type);
}
ulong oid = 0;
ulong finalOid = _owner.GetLastAllocatedOid();
long prevProtectionCounter = 0;
while (true)
{
_keyValueTrProtector.Start();
if (oid == 0)
{
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
if (!_keyValueTr.FindFirstKey())
{
break;
}
}
else
{
if (_keyValueTrProtector.WasInterupted(prevProtectionCounter))
{
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
oid++;
var key = BuildKeyFromOid(oid);
var result = _keyValueTr.Find(ByteBuffer.NewSync(key));
if (result == FindResult.Previous)
{
if (!_keyValueTr.FindNextKey())
{
result = FindResult.NotFound;
}
}
if (result == FindResult.NotFound)
{
oid--;
break;
}
}
else
{
if (!_keyValueTr.FindNextKey())
{
break;
}
}
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
}
oid = ReadOidFromCurrentKeyInTransaction();
var o = GetObjFromObjCacheByOid(oid);
if (o != null)
{
if (type == null || type.IsInstanceOfType(o))
{
yield return(o);
}
continue;
}
TableInfo tableInfo;
var reader = ReadObjStart(oid, out tableInfo);
if (type != null && !type.IsAssignableFrom(tableInfo.ClientType))
{
continue;
}
var obj = ReadObjFinish(oid, tableInfo, reader);
yield return(obj);
}
if (_dirtyObjSet == null)
{
yield break;
}
var dirtyObjsToEnum = _dirtyObjSet.Where(p => p.Key > oid && p.Key <= finalOid).ToList();
dirtyObjsToEnum.Sort((p1, p2) =>
{
if (p1.Key < p2.Key)
{
return(-1);
}
if (p1.Key > p2.Key)
{
return(1);
}
return(0);
});
foreach (var dObjPair in dirtyObjsToEnum)
{
var obj = dObjPair.Value;
if (type != null && !type.IsInstanceOfType(obj))
{
continue;
}
yield return(obj);
}
}
void FreeContent(IReaderCtx readerCtx, int cfgId)
{
var config = (ODBDictionaryConfiguration)((IInstanceRegistry)readerCtx).FindInstance(cfgId);
var ctx = (DBReaderWithFreeInfoCtx)readerCtx;
if (config.FreeContent == null)
{
var method = ILBuilder.Instance
.NewMethod <Action <IInternalObjectDBTransaction, AbstractBufferedReader, IList <ulong> > >(
$"IDictFinder_Cfg_{cfgId}");
var ilGenerator = method.Generator;
var readerLoc = ilGenerator.DeclareLocal(typeof(IReaderCtx));
ilGenerator
.Ldarg(0)
.Ldarg(1)
.Ldarg(2)
.Newobj(() => new DBReaderWithFreeInfoCtx(null, null, null))
.Stloc(readerLoc);
Action <IILGen> readerOrCtx;
if (_valueHandler.NeedsCtx())
{
readerOrCtx = il => il.Ldloc(readerLoc);
}
else
{
readerOrCtx = il => il.Ldarg(1);
}
_valueHandler.FreeContent(ilGenerator, readerOrCtx);
ilGenerator.Ret();
config.FreeContent = method.Create();
}
var findIDictAction = (Action <IInternalObjectDBTransaction, AbstractBufferedReader, IList <ulong> >)config.FreeContent;
long prevProtectionCounter = 0;
long pos = 0;
while (true)
{
_keyValueTrProtector.Start();
if (pos == 0)
{
_keyValueTr.SetKeyPrefix(_prefix);
if (!_keyValueTr.FindFirstKey())
{
break;
}
}
else
{
if (_keyValueTrProtector.WasInterupted(prevProtectionCounter))
{
_keyValueTr.SetKeyPrefix(_prefix);
if (!_keyValueTr.SetKeyIndex(pos))
{
break;
}
}
else
{
if (!_keyValueTr.FindNextKey())
{
break;
}
}
}
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
var valueBytes = _keyValueTr.GetValueAsByteArray();
var valueReader = new ByteArrayReader(valueBytes);
findIDictAction(ctx.GetTransaction(), valueReader, ctx.DictIds);
pos++;
}
}
public bool FindNextKey()
{
return(_keyValueDBTransaction.FindNextKey());
}
public IEnumerable <object> Enumerate(Type type)
{
if (type == typeof(object))
{
type = null;
}
else if (type != null)
{
AutoRegisterType(type);
}
var taken = false;
ulong oid = 0;
ulong finalOid = _owner.GetLastAllocatedOid();
long prevProtectionCounter = 0;
try
{
while (true)
{
if (!taken)
{
_keyValueTrProtector.Start(ref taken);
}
if (oid == 0)
{
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
if (!_keyValueTr.FindFirstKey())
{
break;
}
}
else
{
if (_keyValueTrProtector.WasInterupted(prevProtectionCounter))
{
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
oid++;
byte[] key = BuildKeyFromOid(oid);
if (_keyValueTr.FindKey(key, 0, key.Length, FindKeyStrategy.OnlyNext) == FindKeyResult.NotFound)
{
oid--;
break;
}
}
else
{
if (!_keyValueTr.FindNextKey())
{
break;
}
}
}
oid = ReadOidFromCurrentKeyInTransaction();
WeakReference weakObj;
if (_objCache.TryGetValue(oid, out weakObj))
{
var o = weakObj.Target;
if (o != null)
{
if (type == null || type.IsAssignableFrom(o.GetType()))
{
_keyValueTrProtector.Stop(ref taken);
yield return(o);
continue;
}
continue;
}
}
TableInfo tableInfo;
KeyValueDBValueReader reader = ReadObjStart(oid, out tableInfo);
if (type != null && !type.IsAssignableFrom(tableInfo.ClientType))
{
continue;
}
object obj = ReadObjFinish(oid, tableInfo, reader);
_keyValueTrProtector.Stop(ref taken);
yield return(obj);
}
}
finally
{
if (taken)
{
_keyValueTrProtector.Stop();
}
}
var dirtyObjsToEnum = _dirtyObjSet.Where(p => p.Key > oid && p.Key <= finalOid).ToList();
dirtyObjsToEnum.Sort((p1, p2) =>
{
if (p1.Key < p2.Key)
{
return(-1);
}
if (p1.Key > p2.Key)
{
return(1);
}
return(0);
});
foreach (var dObjPair in dirtyObjsToEnum)
{
object obj = dObjPair.Value;
if (type != null && !type.IsAssignableFrom(obj.GetType()))
{
continue;
}
yield return(obj);
}
}
void DoRandomWork()
{
var opCounter = 0;
var random = new Random();
using (var stream = CreateTestStream())
//using (IKeyValueDB db = new KeyValueDBReplayProxy(new KeyValueDB(), new PositionLessStreamWriter(new PositionLessStreamProxy("btdb.log"))))
using (IKeyValueDB db = new KeyValueDB())
{
db.Open(stream, false);
IKeyValueDBTransaction tr = db.StartTransaction();
while (opCounter < 100000)
{
if (opCounter % 1000 == 0)
{
Console.WriteLine(string.Format("Operation {0}", opCounter));
Console.WriteLine(tr.CalculateStats().ToString());
}
opCounter++;
var action = random.Next(100);
if (action < 10)
{
if (action > 1)
{
//Console.WriteLine("Commit");
tr.Commit();
}
else
{
//Console.WriteLine("Rollback");
}
tr.Dispose();
tr = db.StartTransaction();
}
else if (action < 50 || tr.GetKeyIndex() < 0)
{
var key = new byte[random.Next(1, 1000)];
random.NextBytes(key);
//Console.WriteLine(string.Format("CreateKey {0}", key.Length));
tr.CreateKey(key);
}
else if (action < 60)
{
//Console.WriteLine("EraseCurrent");
tr.EraseCurrent();
}
else if (action < 65)
{
//Console.WriteLine("FindNextKey");
tr.FindNextKey();
}
else if (action < 70)
{
//Console.WriteLine("FindPreviousKey");
tr.FindPreviousKey();
}
else
{
var value = new byte[random.Next(1, 100000)];
random.NextBytes(value);
//Console.WriteLine(string.Format("SetValue {0}", value.Length));
tr.SetValue(value);
}
}
tr.Dispose();
}
}
public bool FindNextKey()
{
LogSimpleOperation(KVReplayOperation.FindNextKey);
return(_tr.FindNextKey());
}
void FreeContent(IReaderCtx readerCtx, int cfgId)
{
var config = ODBDictionaryConfiguration.Get(cfgId);
var ctx = (DBReaderWithFreeInfoCtx)readerCtx;
if (config.FreeContent == null)
{
var method = ILBuilder.Instance.NewMethod <FreeContentFun>($"IDictFinder_Cfg_{cfgId}");
var ilGenerator = method.Generator;
var readerLoc = ilGenerator.DeclareLocal(typeof(IReaderCtx));
ilGenerator
.Ldarg(0)
.Ldarg(2)
// ReSharper disable once ObjectCreationAsStatement
.Newobj(() => new DBReaderWithFreeInfoCtx(null, null))
.Stloc(readerLoc);
var readerOrCtx = _valueHandler.NeedsCtx() ? (Action <IILGen>?)(il => il.Ldloc(readerLoc)) : null;
_valueHandler.FreeContent(ilGenerator, il => il.Ldarg(1), readerOrCtx);
ilGenerator.Ret();
config.FreeContent = method.Create();
}
var findIDictAction = (FreeContentFun)config.FreeContent;
long prevProtectionCounter = 0;
long pos = 0;
while (true)
{
if (pos == 0)
{
if (!_keyValueTr.FindFirstKey(_prefix))
{
break;
}
}
else
{
if (_keyValueTr.CursorMovedCounter != prevProtectionCounter)
{
if (!_keyValueTr.SetKeyIndex(_prefix, pos))
{
break;
}
}
else
{
if (!_keyValueTr.FindNextKey(_prefix))
{
break;
}
}
}
prevProtectionCounter = _keyValueTr.CursorMovedCounter;
var valueBytes = _keyValueTr.GetValue();
var valueReader = new SpanReader(valueBytes);
findIDictAction(ctx.GetTransaction(), ref valueReader, ctx.DictIds);
pos++;
}
}
