uint ReadRelationVersions(uint relationIndex, string name, Dictionary <uint, RelationVersionInfo> relationVersions)
{
uint lastPersistedVersion = 0;
var relationInfoResolver = new RelationInfoResolver((ObjectDB)_tr.Owner);
var writer = new ByteBufferWriter();
writer.WriteByteArrayRaw(ObjectDB.RelationVersionsPrefix);
writer.WriteVUInt32(relationIndex);
_trkv.SetKeyPrefix(writer.Data);
if (!_trkv.FindFirstKey())
{
return(lastPersistedVersion);
}
var keyReader = new KeyValueDBKeyReader(_trkv);
var valueReader = new KeyValueDBValueReader(_trkv);
do
{
keyReader.Restart();
valueReader.Restart();
lastPersistedVersion = keyReader.ReadVUInt32();
var relationVersionInfo = RelationVersionInfo.LoadUnresolved(valueReader, name);
relationVersionInfo.ResolveFieldHandlers(relationInfoResolver.FieldHandlerFactory);
relationVersions[lastPersistedVersion] = relationVersionInfo;
} while (_trkv.FindNextKey());
return(lastPersistedVersion);
}
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());
}
object ReadObjFinish(ulong oid, TableInfo tableInfo, KeyValueDBValueReader reader)
{
var tableVersion = reader.ReadVUInt32();
var obj = tableInfo.GetLoader(tableVersion)(this, oid, reader);
_objCache.TryAdd(oid, new WeakReference(obj));
return(obj);
}
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();
}
}
}
static IEnumerable <string> LoadTablesEnum(IKeyValueDBTransaction tr)
{
tr.SetKeyPrefix(TableNamesPrefix);
var valueReader = new KeyValueDBValueReader(tr);
while (tr.Enumerate())
{
valueReader.Restart();
yield return(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()));
}
}
KeyValueDBValueReader ReadObjStart(ulong oid, out TableInfo tableInfo)
{
var reader = new KeyValueDBValueReader(_keyValueTr);
var tableId = reader.ReadVUInt32();
tableInfo = _owner.TablesInfo.FindById(tableId);
if (tableInfo == null)
{
throw new BTDBException(string.Format("Unknown TypeId {0} of Oid {1}", tableId, oid));
}
EnsureClientTypeNotNull(tableInfo);
return(reader);
}
TableVersionInfo GetTableVersionInfo(uint tableId, uint version)
{
TableVersionInfo res;
if (_tableVersionInfos.TryGetValue(new TableIdVersion(tableId, version), out res))
{
return(res);
}
_trkv.SetKeyPrefixUnsafe(ObjectDB.TableVersionsPrefix);
if (_trkv.Find(TwiceVuint2ByteBuffer(tableId, version)) == FindResult.Exact)
{
var reader = new KeyValueDBValueReader(_trkv);
res = TableVersionInfo.Load(reader, _tr.Owner.FieldHandlerFactory, _tableId2Name[tableId]);
_tableVersionInfos.Add(new TableIdVersion(tableId, version), res);
return(res);
}
throw new ArgumentException($"TableVersionInfo not found {tableId}-{version}");
}
void IterateOid(ulong oid)
{
if (!_visitedOids.Add(oid))
{
return;
}
_tr.TransactionProtector.Start();
_trkv.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
if (_trkv.Find(Vuint2ByteBuffer(oid)) != FindResult.Exact)
{
return; // Object oid was deleted
}
_fastVisitor.MarkCurrentKeyAsUsed(_trkv);
var reader = new KeyValueDBValueReader(_trkv);
var tableId = reader.ReadVUInt32();
var version = reader.ReadVUInt32();
MarkTableIdVersionFieldInfo(tableId, version);
string tableName;
if (_visitor != null && !_visitor.StartObject(oid, tableId, _tableId2Name.TryGetValue(tableId, out tableName) ? tableName : null,
version))
{
return;
}
var tvi = GetTableVersionInfo(tableId, version);
var knownInlineId = new HashSet <int>();
for (var i = 0; i < tvi.FieldCount; i++)
{
var fi = tvi[i];
if (_visitor == null || _visitor.StartField(fi.Name))
{
IterateHandler(reader, fi.Handler, false, knownInlineId);
_visitor?.EndField();
}
else
{
IterateHandler(reader, fi.Handler, true, knownInlineId);
}
}
_visitor?.EndObject();
}
public IEnumerable <UnseenKey> UnseenKeys()
{
using (var trkv = _keyValueDb.StartReadOnlyTransaction())
{
foreach (var prefix in SupportedKeySpaces())
{
trkv.SetKeyPrefixUnsafe(prefix);
if (!trkv.FindFirstKey())
{
continue;
}
var reader = new KeyValueDBValueReader(trkv);
do
{
reader.Restart();
yield return(new UnseenKey
{
Key = Merge(prefix, trkv.GetKeyAsByteArray()),
ValueSize = reader.ReadVUInt32()
});
} while (trkv.FindNextKey());
}
}
}
void IterateDict(ulong dictId, IFieldHandler keyHandler, IFieldHandler valueHandler)
{
if (_visitor != null && !_visitor.StartDictionary())
{
return;
}
var o = ObjectDB.AllDictionariesPrefix.Length;
var prefix = new byte[o + PackUnpack.LengthVUInt(dictId)];
Array.Copy(ObjectDB.AllDictionariesPrefix, prefix, o);
PackUnpack.PackVUInt(prefix, ref o, dictId);
_trkv.SetKeyPrefix(prefix);
var protector = _tr.TransactionProtector;
long prevProtectionCounter = 0;
long pos = 0;
while (true)
{
protector.Start();
if (pos == 0)
{
_trkv.SetKeyPrefix(prefix);
if (!_trkv.FindFirstKey())
{
break;
}
}
else
{
if (protector.WasInterupted(prevProtectionCounter))
{
_trkv.SetKeyPrefix(prefix);
if (!_trkv.SetKeyIndex(pos))
{
break;
}
}
else
{
if (!_trkv.FindNextKey())
{
break;
}
}
}
_fastVisitor.MarkCurrentKeyAsUsed(_trkv);
prevProtectionCounter = protector.ProtectionCounter;
if (_visitor == null || _visitor.StartDictKey())
{
var keyReader = new KeyValueDBKeyReader(_trkv);
IterateHandler(keyReader, keyHandler, false, null);
_visitor?.EndDictKey();
}
if (protector.WasInterupted(prevProtectionCounter))
{
_trkv.SetKeyPrefix(prefix);
if (!_trkv.SetKeyIndex(pos))
{
break;
}
}
if (_visitor == null || _visitor.StartDictValue())
{
var valueReader = new KeyValueDBValueReader(_trkv);
IterateHandler(valueReader, valueHandler, false, null);
_visitor?.EndDictValue();
}
pos++;
}
_visitor?.EndDictionary();
}
void IterateRelation(uint relationIndex, string name)
{
var relationVersions = new Dictionary <uint, RelationVersionInfo>();
var lastPersistedVersion = ReadRelationVersions(relationIndex, name, relationVersions);
_tr.TransactionProtector.Start();
var o = ObjectDB.AllRelationsPKPrefix.Length;
var prefix = new byte[o + PackUnpack.LengthVUInt(relationIndex)];
Array.Copy(ObjectDB.AllRelationsPKPrefix, prefix, o);
PackUnpack.PackVUInt(prefix, ref o, relationIndex);
var protector = _tr.TransactionProtector;
long prevProtectionCounter = 0;
long pos = 0;
while (true)
{
protector.Start();
if (pos == 0)
{
_trkv.SetKeyPrefix(prefix);
if (!_trkv.FindFirstKey())
{
break;
}
}
else
{
if (protector.WasInterupted(prevProtectionCounter))
{
_trkv.SetKeyPrefix(prefix);
if (!_trkv.SetKeyIndex(pos))
{
break;
}
}
else
{
if (!_trkv.FindNextKey())
{
break;
}
}
}
_fastVisitor.MarkCurrentKeyAsUsed(_trkv);
prevProtectionCounter = protector.ProtectionCounter;
if (_visitor == null || _visitor.StartRelationKey())
{
var keyReader = new KeyValueDBKeyReader(_trkv);
var relationInfo = relationVersions[lastPersistedVersion];
IterateFields(keyReader, relationInfo.GetPrimaryKeyFields(), null);
_visitor?.EndRelationKey();
}
if (protector.WasInterupted(prevProtectionCounter))
{
_trkv.SetKeyPrefix(prefix);
if (!_trkv.SetKeyIndex(pos))
{
break;
}
}
if (_visitor == null || _visitor.StartRelationValue())
{
var valueReader = new KeyValueDBValueReader(_trkv);
var version = valueReader.ReadVUInt32();
var relationInfo = relationVersions[version];
IterateFields(valueReader, relationInfo.GetValueFields(), new HashSet <int>());
_visitor?.EndRelationValue();
}
pos++;
}
}
static IEnumerable<string> LoadTablesEnum(IKeyValueDBTransaction tr)
{
tr.SetKeyPrefix(TableNamesPrefix);
var valueReader = new KeyValueDBValueReader(tr);
while (tr.Enumerate())
{
valueReader.Restart();
yield return valueReader.ReadString();
}
}
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);
}
}
