public void correct_entry_is_returned() { var memTable = new HashListMemTable(maxSize: 10); memTable.Add(0x11, 0x01, 0xffff); memTable.Add(0x11, 0x02, 0xfff2); using (var ptable = PTable.FromMemtable(memTable, Filename)) { IndexEntry entry; Assert.IsTrue(ptable.TryGetOldestEntry(0x11, out entry)); Assert.AreEqual(0x11, entry.Stream); Assert.AreEqual(0x01, entry.Version); Assert.AreEqual(0xffff, entry.Position); } }
public void throw_exception_if_index_entries_not_descending_during_ptable_get_latest_entry(byte version, bool skipIndexVerify) { string ptableFileName = ConstructPTable(version); CorruptPTableFile(ptableFileName, version, "zeroOutMiddleEntries"); //loading with a depth of 1 should load only 2 midpoints (first and last index entry) PTable pTable = PTable.FromFile(ptableFileName, Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, 1, skipIndexVerify); IndexEntry entry; Assert.Throws <MaybeCorruptIndexException>(() => // changed 2 to 4 here because the corruption actually removes the stream at /2, so it isn't in the bloom filter pTable.TryGetLatestEntry(GetOriginalHash(numIndexEntries / 4, version), out entry)); pTable.Dispose(); }
public void only_entry_with_largest_position_is_returned_when_triduplicated() { var memTable = new HashListMemTable(_ptableVersion, maxSize: 10); memTable.Add(0x010100000000, 0x01, 0xfff1); memTable.Add(0x010100000000, 0x01, 0xfff3); memTable.Add(0x010100000000, 0x01, 0xfff5); using (var ptable = PTable.FromMemtable(memTable, Filename, Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, skipIndexVerify: _skipIndexVerify)) { IndexEntry entry; Assert.IsTrue(ptable.TryGetLatestEntry(0x010100000000, out entry)); Assert.AreEqual(GetHash(0x010100000000), entry.Stream); Assert.AreEqual(0x01, entry.Version); Assert.AreEqual(0xfff5, entry.Position); } }
public void correct_entry_is_returned() { var memTable = new HashListMemTable(_ptableVersion, maxSize: 10); memTable.Add(0x010100000000, 0x01, 0xffff); memTable.Add(0x010100000000, 0x02, 0xfff2); using (var ptable = PTable.FromMemtable(memTable, Filename, skipIndexVerify: _skipIndexVerify)) { IndexEntry entry; Assert.IsTrue(ptable.TryGetLatestEntry(0x010100000000, out entry)); Assert.AreEqual(GetHash(0x010100000000), entry.Stream); Assert.AreEqual(0x02, entry.Version); Assert.AreEqual(0xfff2, entry.Position); } }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); var table = new HashListMemTable(); table.Add(0x0101, 0x0001, 0x0001); table.Add(0x0105, 0x0001, 0x0002); table.Add(0x0102, 0x0001, 0x0003); table.Add(0x0102, 0x0002, 0x0004); table.Add(0x0103, 0x0001, 0xFFF1); table.Add(0x0103, 0x0003, 0xFFF3); table.Add(0x0103, 0x0005, 0xFFF5); _ptable = PTable.FromMemtable(table, Filename, cacheDepth: 0); }
public void the_hash_of_file_is_valid() { var tmp = Path.GetRandomFileName(); var table = new HashListMemTable(); table.Add(0x0101, 0x0001, 0x0001); table.Add(0x0105, 0x0001, 0x0002); table.Add(0x0102, 0x0001, 0x0003); table.Add(0x0102, 0x0002, 0x0003); using (var sstable = PTable.FromMemtable(table, tmp)) { Assert.DoesNotThrow(() => sstable.VerifyFileHash()); } File.Delete(tmp); }
public void the_largest_items_are_returned_in_descending_order() { var entries = PTable.GetRange(1, 0, 0).ToArray(); Assert.AreEqual(3, entries.Length); Assert.AreEqual(1, entries[0].Stream); Assert.AreEqual(0, entries[0].Version); Assert.AreEqual(0x0005, entries[0].Position); Assert.AreEqual(1, entries[1].Stream); Assert.AreEqual(0, entries[1].Version); Assert.AreEqual(0x0004, entries[1].Position); Assert.AreEqual(1, entries[2].Stream); Assert.AreEqual(0, entries[2].Version); Assert.AreEqual(0x0003, entries[2].Position); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); var table = new HashListMemTable(_ptableVersion, maxSize: 50); table.Add(0x010100000000, 0x0001, 0x0001); table.Add(0x010500000000, 0x0001, 0x0002); table.Add(0x010200000000, 0x0001, 0x0003); table.Add(0x010200000000, 0x0002, 0x0004); table.Add(0x010300000000, 0x0001, 0xFFF1); table.Add(0x010300000000, 0x0003, 0xFFF3); table.Add(0x010300000000, 0x0005, 0xFFF5); _ptable = PTable.FromMemtable(table, Filename, cacheDepth: 0, skipIndexVerify: _skipIndexVerify); }
public void the_file_gets_created_and_can_be_read() { var indexEntrySize = PTable.IndexEntryV4Size; if (_ptableVersion == PTableVersions.IndexV1) { indexEntrySize = PTable.IndexEntryV1Size; } else if (_ptableVersion == PTableVersions.IndexV2) { indexEntrySize = PTable.IndexEntryV2Size; } else if (_ptableVersion == PTableVersions.IndexV3) { indexEntrySize = PTable.IndexEntryV3Size; } var table = new HashListMemTable(_ptableVersion, maxSize: 10); table.Add(0x010100000000, 0x0001, 0x0001); table.Add(0x010500000000, 0x0001, 0x0002); table.Add(0x010200000000, 0x0001, 0x0003); table.Add(0x010200000000, 0x0002, 0x0003); using (var sstable = PTable.FromMemtable(table, Filename, Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, skipIndexVerify: _skipIndexVerify, useBloomFilter: true)) { var fileinfo = new FileInfo(Filename); var midpointsCached = PTable.GetRequiredMidpointCountCached(4, _ptableVersion); Assert.AreEqual( PTableHeader.Size + 4 * indexEntrySize + midpointsCached * indexEntrySize + PTableFooter.GetSize(_ptableVersion) + PTable.MD5Size, fileinfo.Length); var items = sstable.IterateAllInOrder().ToList(); Assert.AreEqual(GetHash(0x010500000000), items[0].Stream); Assert.AreEqual(0x0001, items[0].Version); Assert.AreEqual(GetHash(0x010200000000), items[1].Stream); Assert.AreEqual(0x0002, items[1].Version); Assert.AreEqual(GetHash(0x010200000000), items[2].Stream); Assert.AreEqual(0x0001, items[2].Version); Assert.AreEqual(GetHash(0x010100000000), items[3].Stream); Assert.AreEqual(0x0001, items[3].Version); var stream = (ulong)0x010200000000; Assert.True(sstable.TryGetLatestEntry(stream, out var entry)); Assert.AreEqual(GetHash(stream), entry.Stream); Assert.AreEqual(0x0002, entry.Version); Assert.AreEqual(0x0003, entry.Position); } }
public void when_ptable_header_is_corrupted() { _ptable.Dispose(); _ptable = null; using (var fs = File.Open(_ptableFileName, FileMode.Open)) { fs.Position = new Random().Next(0, PTableHeader.Size); var b = (byte)fs.ReadByte(); b ^= 1; fs.Position -= 1; fs.WriteByte(b); } Assert.Throws <CorruptIndexException>(() => IndexMap.FromFile(_indexMapFileName, maxTablesPerLevel: 2)); }
public void when_duplicated_entries_exist_the_one_with_oldest_position_is_returned() { var memTable = new HashListMemTable(_ptableVersion, maxSize: 10); memTable.Add(0x010100000000, 0x01, 0xfff1); memTable.Add(0x010100000000, 0x02, 0xfff2); memTable.Add(0x010100000000, 0x01, 0xfff3); memTable.Add(0x010100000000, 0x02, 0xfff4); using (var ptable = PTable.FromMemtable(memTable, Filename, skipIndexVerify: _skipIndexVerify)) { IndexEntry entry; Assert.IsTrue(ptable.TryGetOldestEntry(0x010100000000, out entry)); Assert.AreEqual(GetHash(0x010100000000), entry.Stream); Assert.AreEqual(0x01, entry.Version); Assert.AreEqual(0xfff1, entry.Position); } }
public void when_ptable_data_is_corrupted() { _ptable.Dispose(); _ptable = null; using (var fs = File.Open(_ptableFileName, FileMode.Open)) { fs.Position = new Random().Next(PTableHeader.Size, (int)fs.Length); var b = (byte)fs.ReadByte(); b ^= 1; fs.Position -= 1; fs.WriteByte(b); } Assert.Throws <CorruptIndexException>(() => IndexMap.FromFile(_indexMapFileName, x => false, 2)); }
public void for_a_fixed_number_of_index_entries_and_increasing_min_depth_midpoint_count_should_increase_monotonically() { for (long numIndexEntries = 0; numIndexEntries < MAX_INDEX_ENTRIES; numIndexEntries += getIncrement(numIndexEntries)) { long prevMidpointCount = 0L; for (int minDepth = 0; minDepth <= MAX_TEST_DEPTH; minDepth++) { string testCase = $"numIndexEntries: {numIndexEntries}, minDepth: {minDepth}"; var midpointCount = PTable.GetRequiredMidpointCountCached(numIndexEntries, PTableVersions.IndexV4, minDepth); Assert.GreaterOrEqual(midpointCount, prevMidpointCount, testCase); Assert.GreaterOrEqual(midpointCount, Math.Min(1 << Math.Min(MAX_DEPTH, minDepth), numIndexEntries), testCase); Assert.LessOrEqual(midpointCount, Math.Max(2, numIndexEntries), testCase); prevMidpointCount = midpointCount; } } }
public void Setup() { for (int i = 0; i < 4; i++) { _files.Add(Path.GetRandomFileName()); var table = new HashListMemTable(); for (int j = 0; j < 10; j++) { table.Add((UInt32)j + 1, i + 1, i * j); } _tables.Add(PTable.FromMemtable(table, _files[i])); } _files.Add(Path.GetRandomFileName()); _newtable = PTable.MergeTo(_tables, _files[4], x => false); }
public void only_entry_with_largest_position_is_returned_when_triduplicated() { var memTable = new HashListMemTable(); memTable.Add(0x11, 0x01, 0xfff1); memTable.Add(0x11, 0x01, 0xfff3); memTable.Add(0x11, 0x01, 0xfff5); using (var ptable = PTable.FromMemtable(memTable, Filename)) { IndexEntry entry; Assert.IsTrue(ptable.TryGetLatestEntry(0x11, out entry)); Assert.AreEqual(0x11, entry.Stream); Assert.AreEqual(0x01, entry.Version); Assert.AreEqual(0xfff5, entry.Position); } }
public void when_ptable_hash_is_corrupted() { _ptable.Dispose(); _ptable = null; using (var fs = File.Open(_ptableFileName, FileMode.Open)) { fs.Seek(-PTable.MD5Size, SeekOrigin.End); var b = (byte)fs.ReadByte(); b ^= 1; fs.Seek(-PTable.MD5Size, SeekOrigin.End); fs.WriteByte(b); } Assert.Throws <CorruptIndexException>(() => IndexMap.FromFile(_indexMapFileName, x => false, 2)); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); var header = new PTableHeader(1); using (var f = File.Open(Filename, FileMode.OpenOrCreate)) { f.Seek(0, SeekOrigin.Begin); var bytes = header.AsByteArray(); f.Write(bytes, 0, bytes.Length); var size = (long)(uint.MaxValue + 10000000L) * (long)PTable.IndexEntrySize + PTableHeader.Size + PTable.MD5Size; Console.WriteLine("allocating file " + Filename + " size is " + size); f.SetLength(size); Console.WriteLine("file allocated"); } _ptable = PTable.FromFile(Filename, 22); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); _filename = GetTempFilePath(); _mergeFile = GetTempFilePath(); _map = IndexMap.FromFile(_filename, x => false, maxTablesPerLevel: 2); var memtable = new HashListMemTable(); memtable.Add(0, 1, 0); _result = _map.AddFile(PTable.FromMemtable(memtable, GetTempFilePath()), 123, 321, new GuidFilenameProvider(PathName)); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddFile(PTable.FromMemtable(memtable, GetTempFilePath()), 100, 400, new FakeFilenameProvider(_mergeFile)); _result.ToDelete.ForEach(x => x.MarkForDestruction()); }
public void only_entry_with_smallest_position_is_returned_when_triduplicated() { var memTable = new HashListMemTable(_ptableVersion, maxSize: 10); memTable.Add(0x010100000000, 0x01, 0xfff1); memTable.Add(0x010100000000, 0x01, 0xfff3); memTable.Add(0x010100000000, 0x01, 0xfff5); using (var ptable = PTable.FromMemtable(memTable, Filename)) { IndexEntry entry; Assert.IsTrue(ptable.TryGetOldestEntry(0x010100000000, out entry)); Assert.AreEqual(GetHash(0x010100000000), entry.Stream); Assert.AreEqual(0x01, entry.Version); Assert.AreEqual(0xfff1, entry.Position); } }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); _filename = GetTempFilePath(); _finalmergefile = GetTempFilePath(); _finalmergefile2 = GetTempFilePath(); _map = IndexMap.FromFile(_filename); var memtable = new HashListMemTable(_ptableVersion, maxSize: 10); memtable.Add(0, 1, 0); var guidFilename = new GuidFilenameProvider(PathName); _result = _map.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 0, 0, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), guidFilename, _ptableVersion, _maxAutoMergeIndexLevel, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath(), skipIndexVerify: _skipIndexVerify), 1, 2, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), new FakeFilenameProvider(_finalmergefile, _finalmergefile2), _ptableVersion, 4, 0, skipIndexVerify: _skipIndexVerify); _result.ToDelete.ForEach(x => x.MarkForDestruction()); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); _filename = GetTempFilePath(); _finalmergefile = GetTempFilePath(); _finalmergefile2 = GetTempFilePath(); _map = IndexMap.FromFile(_filename); var memtable = new HashListMemTable(maxSize: 10); memtable.Add(0, 1, 0); var guidFilename = new GuidFilenameProvider(PathName); _result = _map.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 0, 0, _ => true, guidFilename); _result.ToDelete.ForEach(x => x.MarkForDestruction()); _result = _result.MergedMap.AddPTable(PTable.FromMemtable(memtable, GetTempFilePath()), 1, 2, _ => true, new FakeFilenameProvider(_finalmergefile, _finalmergefile2)); _result.ToDelete.ForEach(x => x.MarkForDestruction()); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); for (int i = 0; i < 2; i++) { _files.Add(GetTempFilePath()); var table = new HashListMemTable(maxSize: 20); for (int j = 0; j < 10; j++) { table.Add((UInt32)j + 1, i + 1, i * j); } _tables.Add(PTable.FromMemtable(table, _files[i])); } _files.Add(GetTempFilePath()); _newtable = PTable.MergeTo(_tables, _files[2], x => false); }
public override void SetUp() { base.SetUp(); _indexMapFileName = Path.Combine(PathName, "index.map"); _ptableFileName = Path.Combine(PathName, "ptable"); var indexMap = IndexMap.FromFile(_indexMapFileName, x => false, maxTablesPerLevel: 2); var memtable = new HashListMemTable(); memtable.Add(0, 0, 0); memtable.Add(1, 1, 100); _ptable = PTable.FromMemtable(memtable, _ptableFileName); indexMap = indexMap.AddFile(_ptable, 0, 0, new GuidFilenameProvider(PathName)).MergedMap; indexMap.SaveToFile(_indexMapFileName); }
public override void SetUp() { base.SetUp(); _indexMapFileName = GetFilePathFor("index.map"); _ptableFileName = GetFilePathFor("ptable"); var indexMap = IndexMap.FromFile(_indexMapFileName, maxTablesPerLevel: 2); var memtable = new HashListMemTable(maxSize: 10); memtable.Add(0, 0, 0); memtable.Add(1, 1, 100); _ptable = PTable.FromMemtable(memtable, _ptableFileName); indexMap = indexMap.AddPTable(_ptable, 0, 0, _ => true, new GuidFilenameProvider(PathName)).MergedMap; indexMap.SaveToFile(_indexMapFileName); }
public override async Task TestFixtureSetUp() { await base.TestFixtureSetUp(); _files.Add(GetTempFilePath()); var table = new HashListMemTable(_fromVersion, maxSize: 20); if (_fromVersion == PTableVersions.IndexV1) { table.Add(0x010100000000, 0, 0x0101); table.Add(0x010200000000, 0, 0x0102); table.Add(0x010300000000, 0, 0x0103); table.Add(0x010400000000, 0, 0x0104); } else { table.Add(0x0101, 0, 0x0101); table.Add(0x0102, 0, 0x0102); table.Add(0x0103, 0, 0x0103); table.Add(0x0104, 0, 0x0104); } _tables.Add(PTable.FromMemtable(table, GetTempFilePath(), Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, skipIndexVerify: _skipIndexVerify)); table = new HashListMemTable(_fromVersion, maxSize: 20); if (_fromVersion == PTableVersions.IndexV1) { table.Add(0x010500000000, 0, 0x0105); table.Add(0x010600000000, 0, 0x0106); table.Add(0x010700000000, 0, 0x0107); table.Add(0x010800000000, 0, 0x0108); } else { table.Add(0x0105, 0, 0x0105); table.Add(0x0106, 0, 0x0106); table.Add(0x0107, 0, 0x0107); table.Add(0x0108, 0, 0x0108); } _tables.Add(PTable.FromMemtable(table, GetTempFilePath(), Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, skipIndexVerify: _skipIndexVerify)); _newtableFile = GetTempFilePath(); _newtable = PTable.MergeTo(_tables, _newtableFile, (streamId, hash) => hash + 1, x => true, x => new Tuple <string, bool>(x.Stream.ToString(), true), PTableVersions.IndexV4, Constants.PTableInitialReaderCount, Constants.PTableMaxReaderCountDefault, skipIndexVerify: _skipIndexVerify); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); _filename = GetTempFilePath(); _tablename = GetTempFilePath(); _mergeFile = GetFilePathFor("mergefile"); _map = IndexMap.FromFile(_filename, x => false); var memtable = new HashListMemTable(maxSize: 10); memtable.Add(0, 1, 0); var table = PTable.FromMemtable(memtable, _tablename); _result = _map.AddFile(table, 7, 11, new FakeFilenameProvider(_mergeFile)); table.MarkForDestruction(); }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); for (int i = 0; i < 4; i++) { _files.Add(GetTempFilePath()); var table = new HashListMemTable(_ptableVersion, maxSize: 30); for (int j = 0; j < 10; j++) { table.Add((ulong)(0x010100000000 << i), j, i * 10 + j); } _tables.Add(PTable.FromMemtable(table, _files[i])); } _files.Add(GetTempFilePath()); _newtable = PTable.MergeTo(_tables, _files[4], (streamId, hash) => hash, x => x.Position % 2 == 0, x => new Tuple <string, bool>("", x.Position % 2 == 0), _ptableVersion); }
public void when_duplicated_entries_exist_the_one_with_latest_position_is_returned() { var memTable = new HashListMemTable(maxSize: 2000); memTable.Add(0x11, 0x01, 0xfff1); memTable.Add(0x11, 0x02, 0xfff2); memTable.Add(0x11, 0x01, 0xfff3); memTable.Add(0x11, 0x02, 0xfff4); using (var ptable = PTable.FromMemtable(memTable, Filename)) { IndexEntry entry; Assert.IsTrue(ptable.TryGetLatestEntry(0x11, out entry)); Assert.AreEqual(0x11, entry.Stream); Assert.AreEqual(0x02, entry.Version); Assert.AreEqual(0xfff4, entry.Position); } }
public override void TestFixtureSetUp() { base.TestFixtureSetUp(); _filename = GetTempFilePath(); _tablename = GetTempFilePath(); _mergeFile = GetFilePathFor("mergefile"); _map = IndexMap.FromFile(_filename); var memtable = new HashListMemTable(_ptableVersion, maxSize: 10); memtable.Add(0, 1, 0); var table = PTable.FromMemtable(memtable, _tablename); _result = _map.AddPTable(table, 7, 11, (streamId, hash) => hash, _ => true, _ => new System.Tuple <string, bool>("", true), new FakeFilenameProvider(_mergeFile), _ptableVersion); table.MarkForDestruction(); }
public override void SetUp() { base.SetUp(); _indexMapFileName = GetFilePathFor("index.map"); _ptableFileName = GetFilePathFor("ptable"); var indexMap = IndexMap.FromFile(_indexMapFileName, maxTablesPerLevel: 2); var memtable = new HashListMemTable(_ptableVersion, maxSize: 10); memtable.Add(0, 0, 0); memtable.Add(1, 1, 100); _ptable = PTable.FromMemtable(memtable, _ptableFileName); indexMap = indexMap.AddPTable(_ptable, 0, 0, (streamId, hash) => hash, _ => true, _ => new Tuple <string, bool>("", true), new GuidFilenameProvider(PathName), _ptableVersion).MergedMap; indexMap.SaveToFile(_indexMapFileName); }