public void CanReadValuesBackWithoutFilter()
{
var state = new StorageState("none", new StorageOptions
{
ParanoidChecks = true,
FilterPolicy = null
});
string name;
using (var file = CreateFile())
{
name = file.Name;
using (var tblBuilder = new TableBuilder(state, file, new TemporaryFiles(state.FileSystem, 1)))
{
for (int i = 0; i < 10; i++)
{
string k = "tests/" + i.ToString("0000");
tblBuilder.Add(new InternalKey(k, 1, ItemType.Value).TheInternalKey, new MemoryStream(Encoding.UTF8.GetBytes(k)));
}
tblBuilder.Finish();
file.Flush(true);
}
}
using (var mmf = MemoryMappedFile.CreateFromFile(name, FileMode.Open))
{
var length = new FileInfo(name).Length;
using (var table = new Table(state, new FileData(new MemoryMappedFileAccessor(name, mmf), length)))
using (var iterator = table.CreateIterator(new ReadOptions()))
{
for (int i = 0; i < 10; i++)
{
string k = "tests/" + i.ToString("0000");
iterator.Seek(new InternalKey(k, 100, ItemType.Value).TheInternalKey);
Assert.True(iterator.IsValid);
using (var stream = iterator.CreateValueStream())
using (var reader = new StreamReader(stream))
{
Assert.Equal(k, reader.ReadToEnd());
}
}
}
}
}
private void WriteMemTableToDisk(MemRange range)
{
string fileName;
Slice first = new Slice(), last = new Slice();
using (var stream = _options.CreateNewTableFile(out fileName))
using (var builder = new TableBuilder(_options, stream, _options.Storage.CreateTemp))
using (var it = range.MemTable.NewIterator())
{
it.SeekToFirst();
while (it.IsValid)
{
if (first.Array == null)
first = it.Key;
last = it.Key;
using (var valueStream = it.CreateValueStream())
builder.Add(it.Key, valueStream);
it.Next();
}
builder.Finish();
_options.Storage.Flush(stream);
}
lock (_metadataLocker)
{
_options.Status.Ranges = new List<CurrentStatus.SstRange>(_options.Status.Ranges)
{
new CurrentStatus.SstRange
{
End = last,
Name = fileName,
Start = first,
Count = range.MemTable.Count
}
};
_options.Status.LastCompletedLog = range.LogNumber;
_options.FlushStatus();
}
}
/// <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;
}