uint ITableInfoResolver.GetLastPesistedVersion(uint id)
{
using (var tr = _keyValueDB.StartTransaction())
{
tr.SetKeyPrefix(TableVersionsPrefix);
var key = new byte[PackUnpack.LengthVUInt(id) + 1];
var ofs = 0;
PackUnpack.PackVUInt(key, ref ofs, id);
key[ofs] = 0xff;
if (tr.FindKey(key, 0, key.Length, FindKeyStrategy.PreferPrevious) == FindKeyResult.NotFound)
{
return(0);
}
var key2 = tr.ReadKey();
if (key2.Length < ofs)
{
return(0);
}
if (BitArrayManipulation.CompareByteArray(key, 0, ofs, key2, 0, ofs) != 0)
{
return(0);
}
return(checked ((uint)PackUnpack.UnpackVUInt(key2, ref ofs)));
}
}
public void Open(IKeyValueDB keyValueDB, bool dispose, DBOptions options)
{
_keyValueDB = keyValueDB ?? throw new ArgumentNullException(nameof(keyValueDB));
_dispose = dispose;
_type2Name = options.CustomType2NameRegistry ?? new Type2NameRegistry();
_polymorphicTypesRegistry = new PolymorphicTypesRegistry();
AutoRegisterTypes = options.AutoRegisterType;
ActualOptions = options;
SymmetricCipher = options.SymmetricCipher ?? new InvalidSymmetricCipher();
_tableInfoResolver = new TableInfoResolver(keyValueDB, this);
_tablesInfo = new TablesInfo(_tableInfoResolver);
_relationsInfoResolver = new RelationInfoResolver(this);
_relationsInfo = new RelationsInfo(_relationsInfoResolver);
using var tr = _keyValueDB.StartTransaction();
_lastObjId = (long)tr.GetUlong(0);
_lastDictId = tr.GetUlong(1);
if (_lastObjId == 0)
{
if (tr.FindLastKey(AllObjectsPrefix))
{
_lastObjId = (long)PackUnpack.UnpackVUInt(tr.GetKey().Slice(AllObjectsPrefixLen));
}
}
_tablesInfo.LoadTables(LoadTablesEnum(tr));
_relationsInfo.LoadRelations(LoadRelationNamesEnum(tr));
if (_lastDictId == 0)
{
if (tr.FindExactKey(LastDictIdKey))
{
_lastDictId = PackUnpack.UnpackVUInt(tr.GetValue());
}
}
}
void PackVUIntIsOrderableCore(ulong t)
{
var buf1 = new byte[9];
var o1 = 0;
PackUnpack.PackVUInt(buf1, ref o1, t - 1);
var buf2 = new byte[9];
var o2 = 0;
PackUnpack.PackVUInt(buf2, ref o2, t);
if (t <= uint.MaxValue)
{
Assert.Equal(o2, PackUnpack.LengthVUInt((uint)t));
}
Assert.Equal(o2, PackUnpack.LengthVUInt(t));
Assert.Equal(o2, PackUnpack.LengthVUInt(buf2, 0));
Assert.True(0 > BitArrayManipulation.CompareByteArray(buf1, o1, buf2, o2));
var o1A = 0;
Assert.Equal(t - 1, PackUnpack.UnpackVUInt(buf1, ref o1A));
Assert.Equal(o1, o1A);
var o2A = 0;
Assert.Equal(t, PackUnpack.UnpackVUInt(buf2, ref o2A));
Assert.Equal(o2, o2A);
}
public ulong ReadVUInt64()
{
NeedOneByteInBuffer();
var l = PackUnpack.LengthVUInt(Buf, Pos);
ulong res;
if (Pos + l <= End)
{
res = PackUnpack.UnpackVUInt(Buf, ref Pos);
}
else
{
res = (ulong)(Buf[Pos] & (0xff >> l));
do
{
Pos++;
res <<= 8;
NeedOneByteInBuffer();
res += Buf[Pos];
l--;
} while (l > 1);
Pos++;
}
return(res);
}
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()));
}
}
ulong ReadOidFromCurrentKeyInTransaction()
{
var key = _keyValueTr.GetKey();
var bufOfs = key.Offset;
var oid = PackUnpack.UnpackVUInt(key.Buffer, ref bufOfs);
return(oid);
}
private void LoadItem()
{
int ofs = _ofs;
_keyLen = (int)PackUnpack.UnpackVUInt(_data, ref ofs);
_valueLen = (long)PackUnpack.UnpackVUInt(_data, ref ofs);
_ofsAfterKeyAndValueLen = ofs;
}
ulong ReadOidFromCurrentKeyInTransaction()
{
int len;
byte[] buf;
int bufOfs;
_keyValueTr.PeekKey(0, out len, out buf, out bufOfs);
ulong oid = PackUnpack.UnpackVUInt(buf, ref bufOfs);
return(oid);
}
internal static void RecalculateHeader(byte[] data, int count)
{
var ofs1 = HeaderSize + HeaderForEntry * count;
var ofs = ofs1;
for (int i = 0; i < count; i++)
{
var keyLen = (int)PackUnpack.UnpackVUInt(data, ref ofs);
var valueLen = (long)PackUnpack.UnpackVUInt(data, ref ofs);
ofs += CalcEntrySizeWOLengths(keyLen, valueLen);
PackUnpack.PackUInt16LE(data, HeaderSize + HeaderForEntry * i, (ushort)(ofs - ofs1));
}
}
void ReceiveBody()
{
try
{
_connector.OnNext(true);
var buf = new byte[9];
while (!_disconnected)
{
if (!Receive(buf, 0, 1))
{
return;
}
var packLen = PackUnpack.LengthVUInt(buf, 0);
if (packLen > 1)
{
if (!Receive(buf, 1, packLen - 1))
{
return;
}
}
int o = 0;
var len = PackUnpack.UnpackVUInt(buf, ref o);
if (len > int.MaxValue)
{
throw new InvalidDataException();
}
var result = new byte[len];
if (len != 0)
{
if (!Receive(result, 0, (int)len))
{
return;
}
}
_receiver.OnNext(ByteBuffer.NewAsync(result));
}
}
catch (Exception)
{
SignalDisconnected();
}
SignalDisconnected();
}
public IEnumerable <UnseenKey> UnseenKeys()
{
using var trkv = _keyValueDb.StartReadOnlyTransaction();
foreach (var prefix in SupportedKeySpaces())
{
if (!trkv.FindFirstKey(prefix))
{
continue;
}
do
{
yield return(new UnseenKey
{
Key = trkv.GetKeyToArray(),
ValueSize = (uint)PackUnpack.UnpackVUInt(trkv.GetValue())
});
} while (trkv.FindNextKey(prefix));
}
}
uint ITableInfoResolver.GetLastPersistedVersion(uint id)
{
using (var tr = _keyValueDB.StartTransaction())
{
tr.SetKeyPrefix(TableVersionsPrefix);
var key = TableInfo.BuildKeyForTableVersions(id, uint.MaxValue);
if (tr.Find(ByteBuffer.NewSync(key)) == FindResult.NotFound)
{
return(0);
}
var key2 = tr.GetKeyAsByteArray();
var ofs = PackUnpack.LengthVUInt(id);
if (key2.Length < ofs)
{
return(0);
}
if (BitArrayManipulation.CompareByteArray(key, ofs, key2, ofs) != 0)
{
return(0);
}
return(checked ((uint)PackUnpack.UnpackVUInt(key2, ref ofs)));
}
}