public FileMetadata(FileMetadata file)
{
FileSize = file.FileSize;
FileNumber = file.FileNumber;
LargestKey = file.LargestKey;
SmallestKey = file.SmallestKey;
}
public static VersionEdit DecodeFrom(Stream stream)
{
var result = new VersionEdit();
while (true)
{
Tag tag;
try
{
tag = (Tag)stream.Read7BitEncodedInt();
}
catch (EndOfStreamException)
{
break;
}
int level;
switch (tag)
{
case Tag.Comparator:
var slice = stream.ReadLengthPrefixedSlice();
result.SetComparatorName(slice);
break;
case Tag.LogNumber:
result.SetLogNumber((ulong)stream.Read7BitEncodedLong());
break;
case Tag.PrevLogNumber:
result.SetPrevLogNumber((ulong)stream.Read7BitEncodedLong());
break;
case Tag.NextFileNumber:
result.SetNextFile((ulong)stream.Read7BitEncodedLong());
break;
case Tag.LastSequence:
result.SetLastSequence((ulong)stream.Read7BitEncodedLong());
break;
case Tag.CompactPointer:
level = stream.Read7BitEncodedInt();
var compactionPointer = stream.ReadLengthPrefixedInternalKey();
result.SetCompactionPointer(level, compactionPointer);
break;
case Tag.DeletedFile:
level = stream.Read7BitEncodedInt();
var fileNumber = (ulong)stream.Read7BitEncodedLong();
result.DeleteFile(level, fileNumber);
break;
case Tag.NewFile:
level = stream.Read7BitEncodedInt();
var fileMetadata = new FileMetadata
{
FileNumber = (ulong)stream.Read7BitEncodedLong(),
FileSize = stream.Read7BitEncodedLong(),
SmallestKey = stream.ReadLengthPrefixedInternalKey(),
LargestKey = stream.ReadLengthPrefixedInternalKey()
};
result.AddFile(level, fileMetadata);
break;
}
}
return result;
}
public void AddFile(int level, FileMetadata file)
{
NewFiles[level].Add(file);
}
private bool AfterFile(IComparator comparator, Slice key, FileMetadata file)
{
// Empty 'key' occurs before all keys and is therefore never after 'file'
return (key.IsEmpty() == false && comparator.Compare(key, file.LargestKey.UserKey) > 0);
}
private bool BeforeFile(IComparator comparator, Slice key, FileMetadata file)
{
// Empty 'key' occurs after all keys and is therefore never before 'file'
return (key.IsEmpty() == false && comparator.Compare(key, file.SmallestKey.UserKey) < 0);
}
/// <summary>
/// Build a Table file from the contents of *iter. The generated file
/// will be named according to meta->number. On success, the rest of
/// *meta will be filled with metadata about the generated table.
/// If no data is present in *iter, meta->file_size will be set to
/// zero, and no Table file will be produced.
/// </summary>
/// <param name="memTable"></param>
/// <param name="fileNumber"></param>
/// <returns></returns>
public FileMetadata BuildTable(MemTable memTable, ulong fileNumber)
{
CancellationToken.ThrowIfCancellationRequested();
TableBuilder builder = null;
var meta = new FileMetadata
{
FileNumber = fileNumber
};
var tableFileName = FileSystem.GetTableFileName(fileNumber);
try
{
var iterator = memTable.NewIterator();
iterator.SeekToFirst();
if (Log.IsDebugEnabled)
Log.Debug("Writing table with {0:#,#;;00} items to {1}", memTable.Count, tableFileName);
if (iterator.IsValid)
{
var tableFile = FileSystem.NewWritable(tableFileName);
builder = new TableBuilder(this, tableFile, new TemporaryFiles(FileSystem, fileNumber));
meta.SmallestKey = new InternalKey(iterator.Key);
while (iterator.IsValid)
{
CancellationToken.ThrowIfCancellationRequested();
var key = iterator.Key;
meta.LargestKey = new InternalKey(key);
if (Log.IsDebugEnabled)
Log.Debug("Writing item with key {0}", meta.LargestKey.DebugVal);
using (var stream = iterator.CreateValueStream())
builder.Add(key, stream);
iterator.Next();
}
builder.Finish();
meta.FileSize = builder.FileSize;
Debug.Assert(meta.FileSize > 0);
}
}
finally
{
if (builder != null)
builder.Dispose();
if (meta.FileSize == 0)
{
FileSystem.DeleteFile(tableFileName);
}
}
return meta;
}
