public void T1()
{
var storageState = new StorageState("test", new StorageOptions());
var random = new Random();
var tables = new List<MemTable>();
var expectedCount = 0;
try
{
ulong seq = 0;
for (var i = 0; i < 100; i++)
{
var table = new MemTable(storageState);
for (var j = 0; j < 1000; j++)
{
var k = random.Next();
var key = string.Format("{0:0000000000000000}", k);
table.Add(seq++, ItemType.Value, key, null);
expectedCount++;
}
tables.Add(table);
}
var iterators = tables.Select(table => table.NewIterator()).ToList();
var comparator = new InternalKeyComparator(new CaseInsensitiveComparator());
using (var iterator = new MergingIterator(comparator, iterators))
{
var actualCount = 0;
iterator.SeekToFirst();
Assert.True(iterator.IsValid);
Slice prev = string.Empty;
while (iterator.IsValid)
{
if (!prev.IsEmpty())
{
Assert.True(comparator.Compare(iterator.Key, prev) > 0);
}
prev = iterator.Key.Clone();
iterator.Next();
actualCount++;
}
Assert.Equal(expectedCount, actualCount);
}
}
finally
{
foreach (var table in tables)
table.Dispose();
}
}
private static IEnumerable<RavenJObject> YieldMemTableContents(MemTable memTable, Reference<Slice> target)
{
using (var iterator = memTable.NewIterator())
{
iterator.Seek(target.Value);
while (iterator.IsValid)
{
target.Value = iterator.Key;
using (var stream = iterator.CreateValueStream())
{
yield return RavenJObject.Load(new BsonReader(stream));
}
iterator.Next();
}
}
}
/// <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;
}