public IDescriptorSerializerContext StoreNewDescriptors(AbstractBufferedWriter writer, object obj)
{
if (obj == null)
{
return(this);
}
InfoForType infoForType;
var iKnowDescriptor = obj as IKnowDescriptor;
if (iKnowDescriptor != null)
{
var descriptor = iKnowDescriptor.GetDescriptor();
if (!_typeOrDescriptor2InfoMap.TryGetValue(descriptor, out infoForType) &&
!_typeSerializersMapping._typeOrDescriptor2Info.TryGetValue(descriptor, out infoForType))
{
infoForType = new InfoForType {
Id = 0, Descriptor = descriptor
};
}
}
else
{
var objType = obj.GetType();
if (!_typeOrDescriptor2InfoMap.TryGetValue(objType, out infoForType) &&
!_typeSerializersMapping._typeOrDescriptor2Info.TryGetValue(objType, out infoForType))
{
var descriptor = _typeSerializers.DescriptorOf(objType);
if (_typeOrDescriptor2InfoMap.TryGetValue(descriptor, out infoForType))
{
_typeOrDescriptor2InfoMap[objType] = infoForType;
}
else if (_typeSerializersMapping._typeOrDescriptor2Info.TryGetValue(descriptor, out infoForType))
{
_typeSerializersMapping._typeOrDescriptor2Info[objType] = infoForType;
}
else
{
infoForType = new InfoForType {
Id = 0, Descriptor = descriptor
};
}
}
}
if (infoForType.Id == 0)
{
AddDescriptor(infoForType);
}
if (!infoForType.KnownNewTypeDiscoverer)
{
infoForType.NewTypeDiscoverer = _typeSerializers.GetNewDescriptorSaver(infoForType.Descriptor);
infoForType.KnownNewTypeDiscoverer = true;
}
var action = infoForType.NewTypeDiscoverer;
if (action != null)
{
action(obj, this);
}
return(this);
}
void StoreDescriptor(ITypeDescriptor descriptor, AbstractBufferedWriter writer)
{
if (descriptor is ListTypeDescriptor)
{
writer.WriteUInt8((byte)TypeCategory.List);
}
else if (descriptor is DictionaryTypeDescriptor)
{
writer.WriteUInt8((byte)TypeCategory.Dictionary);
}
else if (descriptor is ObjectTypeDescriptor)
{
writer.WriteUInt8((byte)TypeCategory.Class);
}
else if (descriptor is EnumTypeDescriptor)
{
writer.WriteUInt8((byte)TypeCategory.Enum);
}
else
{
throw new ArgumentOutOfRangeException();
}
((IPersistTypeDescriptor)descriptor).Persist(writer, (w, d) =>
{
SerializerTypeInfo result;
if (!_typeOrDescriptor2Info.TryGetValue(d, out result))
{
if (!_typeOrDescriptor2InfoNew.TryGetValue(d, out result))
{
throw new BTDBException("Invalid state unknown descriptor " + d.Name);
}
}
w.WriteVInt32(result.Id);
});
}
internal void Save(AbstractBufferedWriter writer)
{
writer.WriteVUInt32((uint)_primaryKeyFields.Count);
foreach (var field in _primaryKeyFields)
{
field.Save(writer);
}
writer.WriteVUInt32((uint)_secondaryKeyFields.Count);
foreach (var field in _secondaryKeyFields)
{
field.Save(writer);
}
writer.WriteVUInt32((uint)_secondaryKeys.Count);
foreach (var key in _secondaryKeys)
{
writer.WriteVUInt32(key.Key);
var info = key.Value;
writer.WriteVUInt32(0); //unused
writer.WriteString(info.Name);
writer.WriteVUInt32((uint)info.Fields.Count);
foreach (var fi in info.Fields)
{
writer.WriteBool(fi.IsFromPrimaryKey);
writer.WriteVUInt32(fi.Index);
}
}
writer.WriteVUInt32((uint)_fields.Length);
for (var i = 0; i < _fields.Length; i++)
{
_fields[i].Save(writer);
}
}
static void StoreObjectCore(TypeSerializers typeSerializers, AbstractBufferedWriter writer, object obj, InfoForType infoForType, ITypeSerializersLightMapping mapping)
{
writer.WriteVUInt32((uint)infoForType.Id);
if (!infoForType.KnownSimpleSaver)
{
infoForType.SimpleSaver = typeSerializers.GetSimpleSaver(infoForType.Descriptor);
infoForType.KnownSimpleSaver = true;
}
var simpleSaver = infoForType.SimpleSaver;
if (simpleSaver != null)
{
simpleSaver(writer, obj);
return;
}
if (!infoForType.KnownComplexSaver)
{
infoForType.ComplexSaver = typeSerializers.GetComplexSaver(infoForType.Descriptor);
infoForType.KnownComplexSaver = true;
}
var complexSaver = infoForType.ComplexSaver;
var ctx = new TypeBinarySerializerContext(mapping, writer, obj);
complexSaver(writer, ctx, obj);
}
public void WriteHeader(AbstractBufferedWriter writer)
{
FileCollectionWithFileInfos.WriteHeader(writer, _guid);
writer.WriteUInt8((byte)KVFileType.PureValuesWithId);
writer.WriteVInt64(_subId);
writer.WriteVInt64(_generation);
}
public void StoreDescriptor(ITypeDescriptor descriptor, AbstractBufferedWriter writer, Func <ITypeDescriptor, uint> descriptor2Id)
{
if (descriptor is ListTypeDescriptor)
{
writer.WriteUInt8((byte)TypeCategory.List);
}
else if (descriptor is DictionaryTypeDescriptor)
{
writer.WriteUInt8((byte)TypeCategory.Dictionary);
}
else if (descriptor is ObjectTypeDescriptor)
{
writer.WriteUInt8((byte)TypeCategory.Class);
}
else if (descriptor is EnumTypeDescriptor)
{
writer.WriteUInt8((byte)TypeCategory.Enum);
}
else if (descriptor is NullableTypeDescriptor)
{
writer.WriteUInt8((byte)TypeCategory.Nullable);
}
else
{
throw new ArgumentOutOfRangeException();
}
var p = descriptor as IPersistTypeDescriptor;
p.Persist(writer, (w, d) => w.WriteVUInt32(descriptor2Id(d)));
}
internal void Store(AbstractBufferedWriter writer)
{
writer.WriteVUInt32(BindingId);
writer.WriteVUInt32(ServiceId);
writer.WriteVUInt32(MethodId);
writer.WriteBool(OneWay);
}
internal void WriteHeader(AbstractBufferedWriter writer)
{
FileCollectionWithFileInfos.WriteHeader(writer, _guid);
writer.WriteUInt8((byte)KVFileType.TransactionLog);
writer.WriteVInt64(_generation);
writer.WriteVInt32((int)_previousFileId);
}
internal void WriteHeader(AbstractBufferedWriter writer)
{
writer.WriteByteArrayRaw(DiskChunkCache.MagicStartOfFile);
writer.WriteUInt8((byte)DiskChunkFileType.HashIndex);
writer.WriteVInt64(_generation);
writer.WriteVUInt32((uint)KeySize);
writer.WriteVUInt64((ulong)KeyValueCount);
}
internal void WriteHeader(AbstractBufferedWriter writer)
{
FileCollectionWithFileInfos.WriteHeader(writer, _guid);
writer.WriteUInt8((byte)KVFileType.HashKeyIndex);
writer.WriteVInt64(_subId);
writer.WriteVInt64(_generation);
writer.WriteVUInt32(_keyLen);
}
internal void Save(AbstractBufferedWriter writer)
{
writer.WriteVUInt32((uint)FieldCount);
for (int i = 0; i < FieldCount; i++)
{
this[i].Save(writer);
}
}
void StartNewPureValueFile()
{
_pureValueFile = _fileCollection.AddFile("hpv");
_pureValueFileWriter = _pureValueFile.GetAppenderWriter();
var fileInfo = new FilePureValuesWithId(_subDBId, _fileCollection.NextGeneration(), _fileCollection.Guid);
fileInfo.WriteHeader(_pureValueFileWriter);
_fileCollection.SetInfo(_pureValueFile.Index, fileInfo);
}
void StartNewHashIndexFile()
{
_hashIndexFile = _fileCollection.AddFile("hid");
_hashIndexWriter = _hashIndexFile.GetAppenderWriter();
var fileInfo = new HashKeyIndex(_subDBId, _fileCollection.NextGeneration(), _fileCollection.Guid, (uint)_keyLen);
fileInfo.WriteHeader(_hashIndexWriter);
_fileCollection.SetInfo(_hashIndexFile.Index, fileInfo);
}
public void Persist(AbstractBufferedWriter writer, Action <AbstractBufferedWriter, ITypeDescriptor> nestedDescriptorPersistor)
{
writer.WriteString(Name);
writer.WriteVUInt32((uint)_fields.Count);
foreach (var pair in _fields)
{
writer.WriteString(pair.Key);
nestedDescriptorPersistor(writer, pair.Value);
}
}
internal void WriteHeader(AbstractBufferedWriter writer)
{
FileCollectionWithFileInfos.WriteHeader(writer, _guid);
writer.WriteUInt8((byte)KVFileType.ModernKeyIndex);
writer.WriteVInt64(_generation);
writer.WriteVUInt32(_trLogFileId);
writer.WriteVUInt32(_trLogOffset);
writer.WriteVUInt64((ulong)_keyValueCount);
writer.WriteVUInt64(_commitUlong);
writer.WriteUInt8((byte)_compressionType);
}
internal static void WriteHeader(AbstractBufferedWriter writer, Guid?guid)
{
if (guid.HasValue)
{
writer.WriteByteArrayRaw(MagicStartOfFileWithGuid);
writer.WriteGuid(guid.Value);
}
else
{
writer.WriteByteArrayRaw(MagicStartOfFile);
}
}
public void StoreObject(AbstractBufferedWriter writer, object obj)
{
if (obj == null)
{
writer.WriteUInt8(0);
return;
}
TypeSerializers typeSerializers;
var infoForType = GetInfoFromObject(obj, out typeSerializers);
StoreObjectCore(typeSerializers, writer, obj, infoForType, this);
}
public void FinishNewDescriptors(AbstractBufferedWriter writer)
{
if (SomeTypeStored)
{
for (int i = _id2InfoMap.Count - 1; i >= 0; i--)
{
writer.WriteVUInt32((uint)(i + _typeSerializersMapping._id2DescriptorMap.Count));
_typeSerializers.StoreDescriptor(_id2InfoMap[i].Descriptor, writer, Descriptor2Id);
}
writer.WriteUInt8(0);
}
}
void MoveValuesContent(AbstractBufferedWriter writer, uint wastefullFileId, uint pvlFileId)
{
const uint blockSize = 256 * 1024;
var wasteFullStream = _keyValueDB.FileCollection.GetFile(wastefullFileId);
var totalSize = wasteFullStream.GetSize();
var blocks = (int)((totalSize + blockSize - 1) / blockSize);
var wasteInMemory = new byte[blocks][];
var pos = 0UL;
var readLimiter = new BytesPerSecondLimiter(_keyValueDB._compactorReadBytesPerSecondLimit);
for (var i = 0; i < blocks; i++)
{
_cancellation.ThrowIfCancellationRequested();
wasteInMemory[i] = new byte[blockSize];
var readSize = totalSize - pos;
if (readSize > blockSize)
{
readSize = blockSize;
}
wasteFullStream.RandomRead(wasteInMemory[i], 0, (int)readSize, pos, true);
pos += readSize;
readLimiter.Limit(pos);
}
_root.Iterate((valueFileId, valueOfs, valueSize) =>
{
if (valueFileId != wastefullFileId)
{
return;
}
var size = (uint)Math.Abs(valueSize);
_newPositionMap.Add(((ulong)wastefullFileId << 32) | valueOfs,
((ulong)pvlFileId << 32) + (ulong)writer.GetCurrentPosition());
pos = valueOfs;
while (size > 0)
{
_cancellation.ThrowIfCancellationRequested();
var blockId = pos / blockSize;
var blockStart = pos % blockSize;
var writeSize = (uint)(blockSize - blockStart);
if (writeSize > size)
{
writeSize = size;
}
writer.WriteBlock(wasteInMemory[blockId], (int)blockStart, (int)writeSize);
size -= writeSize;
pos += writeSize;
_writerBytesPerSecondLimiter.Limit((ulong)writer.GetCurrentPosition());
}
});
}
public void Store(AbstractBufferedWriter writer)
{
writer.WriteString(_name);
writer.WriteVUInt32((uint)_methodInfs.Length);
foreach (var methodInf in _methodInfs)
{
methodInf.Store(writer);
}
writer.WriteVUInt32((uint)PropertyInfs.Length);
foreach (var propertyInf in PropertyInfs)
{
propertyInf.Store(writer);
}
}
// ReSharper disable UnusedMember.Global
public static void SaverImpl <T>(AbstractBufferedWriter writer, IList <T> ilist) where T : class
// ReSharper restore UnusedMember.Global
{
if (ilist == null)
{
writer.WriteVUInt32(0);
return;
}
var oids = ((ListOfDBObject <T>)ilist).Oids;
writer.WriteVUInt32((uint)oids.Count);
foreach (var oid in oids)
{
writer.WriteVUInt64(oid);
}
}
public void Persist(AbstractBufferedWriter writer, Action <AbstractBufferedWriter, ITypeDescriptor> nestedDescriptorPersistor)
{
writer.WriteString(_name);
writer.WriteVUInt32((_signed ? 1u : 0) + (_flags ? 2u : 0) + 4u * (uint)_pairs.Count);
foreach (var pair in _pairs)
{
writer.WriteString(pair.Key);
if (_signed)
{
writer.WriteVInt64((long)pair.Value);
}
else
{
writer.WriteVUInt64(pair.Value);
}
}
}
internal void WriteHeader(AbstractBufferedWriter writer)
{
FileCollectionWithFileInfos.WriteHeader(writer, _guid);
writer.WriteUInt8((byte)KVFileType.ModernKeyIndexWithUlongs);
writer.WriteVInt64(_generation);
writer.WriteVUInt32(_trLogFileId);
writer.WriteVUInt32(_trLogOffset);
writer.WriteVUInt64((ulong)_keyValueCount);
writer.WriteVUInt64(_commitUlong);
writer.WriteUInt8((byte)_compressionType);
var ulongCount = (uint)(_ulongs?.Length ?? 0);
writer.WriteVUInt32(ulongCount);
if (ulongCount > 0)
{
for (var i = 0; i < ulongCount; i++)
{
writer.WriteVUInt64(_ulongs ![i]);
void WriteStartOfNewTransactionLogFile()
{
if (_writerWithTransactionLog != null)
{
_writerWithTransactionLog.WriteUInt8((byte)KVCommandType.EndOfFile);
_writerWithTransactionLog.FlushBuffer();
_fileWithTransactionLog.HardFlush();
_fileWithTransactionLog.Truncate();
_fileIdWithPreviousTransactionLog = _fileIdWithTransactionLog;
}
_fileWithTransactionLog = FileCollection.AddFile("trl");
_fileIdWithTransactionLog = _fileWithTransactionLog.Index;
var transactionLog = new FileTransactionLog(FileCollection.NextGeneration(), FileCollection.Guid, _fileIdWithPreviousTransactionLog);
_writerWithTransactionLog = _fileWithTransactionLog.GetAppenderWriter();
transactionLog.WriteHeader(_writerWithTransactionLog);
FileCollection.SetInfo(_fileIdWithTransactionLog, transactionLog);
}
public void Store(AbstractBufferedWriter writer)
{
writer.WriteString(_name);
writer.WriteString(_ifaceName);
if (_resultFieldHandler != null)
{
writer.WriteString(_resultFieldHandler.Name);
writer.WriteByteArray(_resultFieldHandler.Configuration);
}
else
{
writer.WriteString(null);
}
writer.WriteVUInt32((uint)_parameters.Length);
foreach (var parameter in _parameters)
{
parameter.Store(writer);
}
}
internal void WriteStartTransaction()
{
if (_fileIdWithTransactionLog == 0)
{
WriteStartOfNewTransactionLogFile();
}
else
{
if (_writerWithTransactionLog == null)
{
_fileWithTransactionLog = FileCollection.GetFile(_fileIdWithTransactionLog);
_writerWithTransactionLog = _fileWithTransactionLog.GetAppenderWriter();
}
if (_writerWithTransactionLog.GetCurrentPosition() > MaxTrLogFileSize)
{
WriteStartOfNewTransactionLogFile();
}
}
_writerWithTransactionLog.WriteUInt8((byte)KVCommandType.TransactionStart);
_writerWithTransactionLog.WriteByteArrayRaw(MagicStartOfTransaction);
}
public IDescriptorSerializerContext StoreNewDescriptors(AbstractBufferedWriter writer, object?obj)
{
if (obj == null)
{
return(this);
}
InfoForType infoForType;
var objType = obj.GetType();
if (obj is IKnowDescriptor iKnowDescriptor)
{
var descriptor = iKnowDescriptor.GetDescriptor();
if (!_typeOrDescriptor2Info.TryGetValue(descriptor, out infoForType))
{
infoForType = new InfoForType {
Id = 0, Descriptor = descriptor
};
}
}
else
{
if (!_typeOrDescriptor2Info.TryGetValue(objType, out infoForType))
{
var descriptor = _typeSerializers.DescriptorOf(objType);
if (!_typeOrDescriptor2Info.TryGetValue(descriptor !, out infoForType))
{
infoForType = new InfoForType {
Id = 0, Descriptor = descriptor
};
}
else
{
_typeOrDescriptor2Info[objType] = infoForType;
}
}
}
public KeyValueDBReplayProxy(IKeyValueDB db, AbstractBufferedWriter log)
{
_db = db;
_log = log;
}
public DBWriterCtx(IInternalObjectDBTransaction transaction, AbstractBufferedWriter writer)
{
_transaction = transaction;
_writer = writer;
}
public void Persist(AbstractBufferedWriter writer, Action <AbstractBufferedWriter, ITypeDescriptor> nestedDescriptorPersistor)
{
nestedDescriptorPersistor(writer, _keyDescriptor);
nestedDescriptorPersistor(writer, _valueDescriptor);
}
public void FinishNewDescriptors(AbstractBufferedWriter writer)
{
}
