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++; } }