public IList <Author_DocumentEntity> GetAllEntities() { var list = new List <Author_DocumentEntity>(); options.CalcBTreeOrder(4, 4); options.CreateFile = CreatePolicy.Never; options.FileName = Path.GetFileName("C:/Users/Дмитрий/Desktop/DMDProject/DMDProject/TreeAuthor_Document"); int count = 0; using (var tree = new BPlusTree <int, int>(options)) { using (FileStream fs = new FileStream("C:/Users/Дмитрий/Desktop/DMDProject/DMDProject/Author_Document", FileMode.Open)) { using (BinaryReader br = new BinaryReader(fs)) { foreach (var item in tree) { if (count == 50) { return(list); } fs.Seek(item.Value, 0); list.Add(new Author_DocumentEntity() { A_D_id = br.ReadInt32().ToString(), Author_id = br.ReadInt32().ToString(), Document_id = br.ReadInt32().ToString() }); count++; } } } } return(list); }
public ContentStorage(string directory, bool asReadonly) { _disposables = new DisposingList(); _readonly = asReadonly; _storageDir = directory; _dataDir = Path.Combine(directory, "content"); if (!_readonly && !Directory.Exists(_dataDir)) { Directory.CreateDirectory(_dataDir); } _indexDir = Path.Combine(directory, "index"); BPlusTree <string, ContentRecord> .Options options = new BPlusTree <string, ContentRecord> .Options( PrimitiveSerializer.Instance, new ProtoSerializer <ContentRecord, ContentRecord.Builder>() ); options.CacheKeepAliveMaximumHistory = 1000; options.CacheKeepAliveMinimumHistory = 100; options.CacheKeepAliveTimeout = int.MaxValue; options.CachePolicy = asReadonly ? CachePolicy.All : CachePolicy.Recent; options.CreateFile = asReadonly ? CreatePolicy.Never : CreatePolicy.IfNeeded; options.FileName = Path.Combine(directory, "content.index"); options.FileBlockSize = 0x02000; //8kb options.ReadOnly = asReadonly; options.CallLevelLock = asReadonly ? (ILockStrategy) new IgnoreLocking() : new SimpleReadWriteLocking(); options.LockingFactory = asReadonly ? (ILockFactory) new LockFactory <IgnoreLocking>() : new LockFactory <SimpleReadWriteLocking>(); options.CalcBTreeOrder(64, 256); _index = new BPlusTree <string, ContentRecord>(options); _disposables.Add(_index); _index.EnableCount(); }
} //lerCSV() /// <summary> /// Cria a árvore à partir dos dados lidos do CSV /// </summary> /// <param name="dicionario">Dados lidos do CSV</param> /// <returns>Indica se houve erro (false) ou não (true) no processo</returns> public static bool criaArvore(Dictionary <int, DadosOcorrencia> dicionario) { //Cria o componente responsável por serializar os dados a serem escritos na árvore ProtoNetSerializer <DadosOcorrencia> serializer = new ProtoNetSerializer <DadosOcorrencia>(); //Prepara as opções da árvore var tree_options = new BPlusTree <int, DadosOcorrencia> .OptionsV2(PrimitiveSerializer.Int32, serializer); tree_options.CalcBTreeOrder(8, 30); tree_options.CreateFile = CreatePolicy.IfNeeded; tree_options.FileName = path_btree; //Checa se o arquivo já existe if (!File.Exists(path_btree)) { using (var tree = new BPlusTree <int, DadosOcorrencia>(tree_options)) { foreach (KeyValuePair <int, DadosOcorrencia> entry in dicionario) { //Percorre o dicionário e adiciona na árvore tree.Add(entry.Key, entry.Value); } } } //Erro, a árvore já existe! else { return(false); } //Se não houve erros retorna true return(true); } //criaArvore()
public static void Test_DuplicateHandelingOptions() { var options = new BPlusTree <double, string> .OptionsV2(PrimitiveSerializer.Double, PrimitiveSerializer.String); options.CalcBTreeOrder(16, 24); options.FileBlockSize = 8192; options.CreateFile = CreatePolicy.Always; options.FileName = "I:\\test.tmp"; BulkInsertOptions opts = new BulkInsertOptions(); opts.CommitOnCompletion = true; // check how to properly set this value using Roger examples. opts.DuplicateHandling = DuplicateHandling.FirstValueWins; opts.InputIsSorted = true; opts.ReplaceContents = false; var sortedContent = new SortedDictionary <double, string>(); sortedContent.Add(10.0, "Demah"); using (var tree = new BPlusTree <double, string>(options)) { tree.Add(10.0, "Hamed"); tree.BulkInsert(sortedContent, opts); } }
private BPlusTree <string, Tuple <OSSIndexProject, IEnumerable <OSSIndexProjectVulnerability> > > InitialiseProjectVulnerabilitiesCache(string file) { lock (project_vulnerabilities_cache_lock) { BPlusTree <string, Tuple <OSSIndexProject, IEnumerable <OSSIndexProjectVulnerability> > > .OptionsV2 cache_file_options = new BPlusTree <string, Tuple <OSSIndexProject, IEnumerable <OSSIndexProjectVulnerability> > > .OptionsV2(PrimitiveSerializer.String, new BsonSerializer <Tuple <OSSIndexProject, IEnumerable <OSSIndexProjectVulnerability> > >()); cache_file_options.CalcBTreeOrder(4, 128); cache_file_options.CreateFile = CreatePolicy.IfNeeded; cache_file_options.FileName = file; cache_file_options.StoragePerformance = StoragePerformance.CommitToDisk; var c = new BPlusTree <string, Tuple <OSSIndexProject, IEnumerable <OSSIndexProjectVulnerability> > >(cache_file_options); c.EnableCount(); IEnumerable <string> expired_cache_keys = from cache_key in c.Keys where DateTime.UtcNow.Subtract(GetProjectVulnerabilitiesCacheEntry(cache_key).Item2) >= this.ProjectVulnerabilitiesCacheTTL join artifact in ArtifactsWithProjects on GetProjectVulnerabilitiesCacheEntry(cache_key).Item1 equals artifact.ProjectId select cache_key; this.ProjectVulnerabilitiesExpiredCacheKeys = expired_cache_keys; foreach (string k in expired_cache_keys) { if (!c.Remove(k)) { throw new Exception("Error removing expired cache item with key: " + k + "."); } } return(c); } }
public void BPlusTreeDemo() { var options = new BPlusTree<string, DateTime>.OptionsV2(PrimitiveSerializer.String, PrimitiveSerializer.DateTime); options.CalcBTreeOrder(16, 24); options.CreateFile = CreatePolicy.Always; options.FileName = Path.GetTempFileName(); using (var tree = new BPlusTree<string, DateTime>(options)) { var tempDir = new DirectoryInfo(Path.GetTempPath()); foreach (var file in tempDir.GetFiles("*", SearchOption.AllDirectories)) { tree.Add(file.FullName, file.LastWriteTimeUtc); } } options.CreateFile = CreatePolicy.Never; using (var tree = new BPlusTree<string, DateTime>(options)) { var tempDir = new DirectoryInfo(Path.GetTempPath()); foreach (var file in tempDir.GetFiles("*", SearchOption.AllDirectories)) { DateTime cmpDate; if (!tree.TryGetValue(file.FullName, out cmpDate)) Console.WriteLine("New file: {0}", file.FullName); else if (cmpDate != file.LastWriteTimeUtc) Console.WriteLine("Modified: {0}", file.FullName); tree.Remove(file.FullName); } foreach (var item in tree) { Console.WriteLine("Removed: {0}", item.Key); } } }
public static void Run() { Console.WriteLine("Now generating sorted items ..."); int nNewItems = 100000; int nOldItems = 100000; var rnd = new Random(); var sortedItems = new SortedDictionary <double, string>(); int newItem = 0; for (int i = 1; i <= nNewItems; i++) { do { newItem = rnd.Next(0, Int32.MaxValue); }while (sortedItems.ContainsKey(newItem)); sortedItems.Add(newItem, Convert.ToString(rnd.Next(0, Int32.MaxValue))); Console.Write("\rAdding {0,5}% : {1,10:N0}/{2:N0}", Math.Round((((double)i / (double)nNewItems) * 100)), i, nNewItems); } Stopwatch stp = new Stopwatch(); var options = new BPlusTree <double, string> .OptionsV2(PrimitiveSerializer.Double, PrimitiveSerializer.String); options.CalcBTreeOrder(16, 24); options.FileBlockSize = 8192; options.CreateFile = CreatePolicy.Always; options.FileName = "I:\\test.tmp"; BulkInsertOptions opts = new BulkInsertOptions(); opts.CommitOnCompletion = true; // check how to properly set this value using Roger examples. opts.DuplicateHandling = DuplicateHandling.LastValueWins; opts.InputIsSorted = true; opts.ReplaceContents = false; AddUpdateValue update = new AddUpdateValue(); Console.WriteLine(); Console.WriteLine("Now creating tree ..."); using (var tree = new BPlusTree <double, string>(options)) { stp.Start(); for (int i = 0; i < nOldItems; i++) { tree.AddOrUpdate(rnd.Next(0, Int32.MaxValue), ref update); } stp.Stop(); Console.WriteLine("Initial <{0:N0}> items => ET : {1} Speed : {2:N0} item/sec", nOldItems, stp.Elapsed, Math.Round((double)(nOldItems / stp.Elapsed.TotalSeconds), 5)); stp.Restart(); tree.AddRangeSorted(sortedItems, true); stp.Stop(); Console.WriteLine("Bulk <{0:N0}> items => ET : {1} Speed : {2:N0} item/sec", nNewItems, stp.Elapsed, Math.Round((double)(nNewItems / stp.Elapsed.TotalSeconds), 5)); } Console.ReadLine(); }
internal BPlusTree <T1, T2> CreateStoredBPlusForWrite <T1, T2>(string tablePath, ISerializer <T1> keySerializer, ISerializer <T2> valueSerializer) { var options = new BPlusTree <T1, T2> .OptionsV2(keySerializer, valueSerializer); options.CalcBTreeOrder(8, 64); options.CreateFile = CreatePolicy.IfNeeded; options.FileName = tablePath; return(new BPlusTree <T1, T2>(options)); }
public IList <SourceEntity> GetAllEntities() { var list = new List <SourceEntity>(); options.CalcBTreeOrder(4, 4); options.CreateFile = CreatePolicy.Never; options.FileName = Path.GetFileName("C:/Users/Дмитрий/Desktop/DMDProject/DMDProject/TreeSource"); int count = 0; using (var tree = new BPlusTree <int, int>(options)) { using (FileStream fs = new FileStream("C:/Users/Дмитрий/Desktop/DMDProject/DMDProject/Source", FileMode.Open)) { using (BinaryReader br = new BinaryReader(fs)) { foreach (var item in tree) { //if (count == 50) //{ // IComparer<SourceEntity> comparer = new MyOrderingClass(); // list.Sort(comparer); // return list; //} fs.Seek(item.Value, 0); list.Add(new SourceEntity() { Source_id = br.ReadInt32().ToString(), Title = br.ReadString(), Type = br.ReadString() }); count++; } } } } IComparer <SourceEntity> comparer = new MyOrderingClass(); list.Sort(comparer); return(list); }
BPlusTree<Guid, TestInfo>.OptionsV2 GetOptions(TempFile temp) { BPlusTree<Guid, TestInfo>.OptionsV2 options = new BPlusTree<Guid, TestInfo>.OptionsV2( PrimitiveSerializer.Guid, new TestInfoSerializer()); options.CalcBTreeOrder(Marshal.SizeOf(typeof(Guid)), Marshal.SizeOf(typeof(TestInfo))); options.CreateFile = CreatePolicy.IfNeeded; options.FileName = temp.TempPath; // The following three options allow for automatic commit/recovery: options.CallLevelLock = new ReaderWriterLocking(); options.TransactionLogFileName = Path.ChangeExtension(options.FileName, ".tlog"); return options; }
public BinaryStorage(StorageConfiguration configuration) { var options = new BPlusTree <string, Data> .OptionsV2(PrimitiveSerializer.String, new DataSerializer()); options.CreateFile = CreatePolicy.IfNeeded; options.FileName = Path.Combine(configuration.WorkingFolder, "index.bin"); options.CallLevelLock = new ReaderWriterLocking(); options.CachePolicy = CachePolicy.Recent; options.CacheKeepAliveMaximumHistory = cacheSize / (estimatedKeySize + estimatedDataSize); options.CalcBTreeOrder(estimatedKeySize, estimatedDataSize); index = new BPlusTree <string, Data> (options); storageFile = Path.Combine(configuration.WorkingFolder, "storage.bin"); storageStream = new FileStream(storageFile, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite, 4096, FileOptions.Asynchronous | FileOptions.SequentialScan | FileOptions.WriteThrough); }
private static TimeSpan BasicInsertionSpeedTest(int inputSize) { Stopwatch watch = new Stopwatch(); Random rnd = new Random(); string longString = ""; for (int i = 0; i < 300; i++) { longString += (char)rnd.Next(48, 90); } int longStringSize = longString.Length * sizeof(Char); BPlusTree <double, string> .OptionsV2 options = new BPlusTree <double, string> .OptionsV2(PrimitiveSerializer.Double, PrimitiveSerializer.String); //options.CalcBTreeOrder(16, 20); options.CalcBTreeOrder(16, longStringSize); // to write to RAM: //options.CreateFile = CreatePolicy.Never; // to write to disk: options.CreateFile = CreatePolicy.Always; options.FileName = Path.GetTempFileName(); using (var tree = new BPlusTree <double, string>(options)) { watch.Start(); while (inputSize-- > 0) { Console.Write("\rRemaining: {0}", inputSize.ToString("N0", CultureInfo.InvariantCulture)); tree.Add(inputSize, longString); } watch.Stop(); } return(watch.Elapsed); }
public void TestAbortWritersAndRecover() { BPlusTree <KeyInfo, DataValue> .Options options = new BPlusTree <KeyInfo, DataValue> .Options( new KeyInfoSerializer(), new DataValueSerializer(), new KeyInfoComparer()); options.CalcBTreeOrder(32, 300); options.FileName = TempFile.TempPath; options.CreateFile = CreatePolicy.Always; using (TempFile copy = new TempFile()) { copy.Delete(); int minRecordCreated = StartAndAbortWriters(options, copy); using (TempFile.Attach(copy.TempPath + ".recovered")) //used to create the new copy using (TempFile.Attach(copy.TempPath + ".deleted")) //renamed existing file { options.CreateFile = CreatePolicy.Never; int recoveredRecords = BPlusTree <KeyInfo, DataValue> .RecoverFile(options); if (recoveredRecords < RecordsCreated) { Assert.Fail("Unable to recover records, recieved ({0} of {1}).", recoveredRecords, RecordsCreated); } options.FileName = copy.TempPath; recoveredRecords = BPlusTree <KeyInfo, DataValue> .RecoverFile(options); Assert.IsTrue(recoveredRecords >= minRecordCreated, "Expected at least " + minRecordCreated + " found " + recoveredRecords); using (BPlusTree <KeyInfo, DataValue> dictionary = new BPlusTree <KeyInfo, DataValue>(options)) { dictionary.EnableCount(); Assert.AreEqual(recoveredRecords, dictionary.Count); foreach (KeyValuePair <KeyInfo, DataValue> kv in dictionary) { Assert.AreEqual(kv.Key.UID, kv.Value.Key.UID); dictionary.Remove(kv.Key); } Assert.AreEqual(0, dictionary.Count); } } } }
public void TestConcurrency() { mreStop.Reset(); using (TempFile temp = new TempFile()) { BPlusTree <Guid, TestInfo> .OptionsV2 options = new BPlusTree <Guid, TestInfo> .OptionsV2( PrimitiveSerializer.Guid, new TestInfoSerializer()); options.CalcBTreeOrder(16, 24); options.CreateFile = CreatePolicy.Always; options.FileName = temp.TempPath; using (BPlusTree <Guid, TestInfo> tree = new BPlusTree <Guid, TestInfo>(options)) { tree.EnableCount(); var actions = new List <IAsyncResult>(); var tests = new Action <BPlusTree <Guid, TestInfo> >[] { DeleteStuff, UpdateStuff, AddStuff, AddRanges, BulkyInserts, FetchStuff, FetchStuff, FetchStuff, FetchStuff, FetchStuff }; foreach (var t in tests) { actions.Add(t.BeginInvoke(tree, null, null)); } const int waitIterations = 8; // wait for n seconds int timesWaited = 0; do { Trace.TraceInformation("Dictionary.Count = {0}", tree.Count); Thread.Sleep(1000); timesWaited++; } while (timesWaited < waitIterations && Debugger.IsAttached); mreStop.Set(); for (int i = 0; i < actions.Count; i++) { tests[i].EndInvoke(actions[i]); } Trace.TraceInformation("Dictionary.Count = {0}", tree.Count); } } }
public void TestErrorsOnInsertAndDelete() { const int CountPerThread = 100; BPlusTree <KeyInfo, DataValue> .OptionsV2 options = new BPlusTree <KeyInfo, DataValue> .OptionsV2( new KeyInfoSerializer(), new DataValueSerializer(), new KeyInfoComparer()); options.CalcBTreeOrder(32, 300); options.FileName = TempFile.TempPath; options.CreateFile = CreatePolicy.Always; using (BPlusTree <KeyInfo, DataValue> dictionary = new BPlusTree <KeyInfo, DataValue>(options)) using (WorkQueue work = new WorkQueue(Environment.ProcessorCount)) { Exception lastError = null; work.OnError += delegate(object o, ErrorEventArgs e) { lastError = e.GetException(); }; for (int i = 0; i < Environment.ProcessorCount; i++) { work.Enqueue(new ThreadedTest(dictionary, CountPerThread).Run); } for (int i = 0; i < CountPerThread; i++) { if (i % 2 == 0) { try { dictionary.TryAdd(new KeyInfo(Guid.NewGuid(), i), k => { throw new ExpectedException(); }); } catch { } } else { try { dictionary.TryRemove(dictionary.First().Key, (k, v) => { throw new ExpectedException(); }); } catch { } } } Assert.IsTrue(work.Complete(true, 60000)); Assert.IsNull(lastError, "Exception raised in worker: {0}", lastError); } }
public void TestConcurrency() { mreStop.Reset(); using(TempFile temp = new TempFile()) { BPlusTree<Guid, TestInfo>.OptionsV2 options = new BPlusTree<Guid, TestInfo>.OptionsV2( PrimitiveSerializer.Guid, new TestInfoSerializer()); options.CalcBTreeOrder(16, 24); options.CreateFile = CreatePolicy.Always; options.FileName = temp.TempPath; using (BPlusTree<Guid, TestInfo> tree = new BPlusTree<Guid, TestInfo>(options)) { tree.EnableCount(); var actions = new List<IAsyncResult>(); var tests = new Action<BPlusTree<Guid, TestInfo>>[] { DeleteStuff, UpdateStuff, AddStuff, AddRanges, BulkyInserts, FetchStuff, FetchStuff, FetchStuff, FetchStuff, FetchStuff }; foreach (var t in tests) actions.Add(t.BeginInvoke(tree, null, null)); const int waitIterations = 8; // wait for n seconds int timesWaited = 0; do { Trace.TraceInformation("Dictionary.Count = {0}", tree.Count); Thread.Sleep(1000); timesWaited++; } while (timesWaited<waitIterations && Debugger.IsAttached); mreStop.Set(); for (int i = 0; i < actions.Count; i++) { tests[i].EndInvoke(actions[i]); } Trace.TraceInformation("Dictionary.Count = {0}", tree.Count); } } }
public static void Test_AllowUpdates() { var options = new BPlusTree <double, string> .OptionsV2(PrimitiveSerializer.Double, PrimitiveSerializer.String); options.CalcBTreeOrder(16, 24); options.FileBlockSize = 8192; options.CreateFile = CreatePolicy.Always; options.FileName = "I:\\test.tmp"; var sortedContent = new SortedDictionary <double, string>(); sortedContent.Add(10.0, "Demah"); using (var tree = new BPlusTree <double, string>(options)) { tree.Add(10.0, "Hamed"); tree.AddRangeSorted(sortedContent, true); } }
public void BPlusTreeDemo() { var options = new BPlusTree <string, DateTime> .OptionsV2(PrimitiveSerializer.String, PrimitiveSerializer.DateTime); options.CalcBTreeOrder(16, 24); options.CreateFile = CreatePolicy.Always; options.FileName = Path.GetTempFileName(); using (var tree = new BPlusTree <string, DateTime>(options)) { var tempDir = new DirectoryInfo(Path.GetTempPath()); foreach (var file in tempDir.GetFiles("*", SearchOption.AllDirectories)) { tree.Add(file.FullName, file.LastWriteTimeUtc); } } options.CreateFile = CreatePolicy.Never; using (var tree = new BPlusTree <string, DateTime>(options)) { var tempDir = new DirectoryInfo(Path.GetTempPath()); foreach (var file in tempDir.GetFiles("*", SearchOption.AllDirectories)) { DateTime cmpDate; if (!tree.TryGetValue(file.FullName, out cmpDate)) { Console.WriteLine("New file: {0}", file.FullName); } else if (cmpDate != file.LastWriteTimeUtc) { Console.WriteLine("Modified: {0}", file.FullName); } tree.Remove(file.FullName); } foreach (var item in tree) { Console.WriteLine("Removed: {0}", item.Key); } } }
} //criaArvore() /// <summary> /// Busca um valor específico na árvore /// </summary> /// <returns>Dados lidos da árvore</returns> public static List <DadosOcorrencia> buscaValor(string valor) { //Cria uma nova lista para retornar List <DadosOcorrencia> lista = new List <DadosOcorrencia>(); //Cria o componente responsável por desserializar os dados a serem lidos da árvore ProtoNetSerializer <DadosOcorrencia> serializer = new ProtoNetSerializer <DadosOcorrencia>(); //Prepara as opções da árvore var tree_options = new BPlusTree <int, DadosOcorrencia> .OptionsV2(PrimitiveSerializer.Int32, serializer); tree_options.CalcBTreeOrder(8, 30); tree_options.CreateFile = CreatePolicy.IfNeeded; tree_options.FileName = path_btree; //Checa se o arquivo já existe if (File.Exists(path_btree)) { using (var tree = new BPlusTree <int, DadosOcorrencia>(tree_options)) { //Varre a árvore buscando o dado foreach (KeyValuePair <int, DadosOcorrencia> par in tree) { if (par.Value.ocorrencia.localidade.IndexOf(valor, StringComparison.OrdinalIgnoreCase) >= 0) { lista.Add(par.Value); } } } } else { //Erro, a árvore não existe! } //Retorna a lista lida return(lista); } //buscaValor()
public void TestCommonConfiguration() { BPlusTree <KeyInfo, DataValue> .Options options = new BPlusTree <KeyInfo, DataValue> .Options(new KeyInfoSerializer(), new DataValueSerializer(), new KeyInfoComparer()); options.CalcBTreeOrder(32, 300); //we can simply just guess close options.FileName = TempFile.TempPath; options.CreateFile = CreatePolicy.Always; //obviously this is just for testing Assert.AreEqual(FileVersion.Version1, options.FileVersion); Random rand = new Random(); KeyInfo k1 = new KeyInfo(), k2 = new KeyInfo(); using (BPlusTree <KeyInfo, DataValue> tree = new BPlusTree <KeyInfo, DataValue>(options)) { byte[] data = new byte[255]; rand.NextBytes(data); tree.Add(k1, new DataValue(k1, data)); Assert.IsTrue(tree.ContainsKey(k1)); Assert.IsFalse(tree.ContainsKey(k1.Next())); Assert.AreEqual(data, tree[k1].Bytes); rand.NextBytes(data); tree.Add(k2, new DataValue(k2, data)); Assert.IsTrue(tree.ContainsKey(k2)); Assert.IsFalse(tree.ContainsKey(k2.Next())); Assert.AreEqual(data, tree[k2].Bytes); } options.CreateFile = CreatePolicy.Never; using (BPlusTree <KeyInfo, DataValue> tree = new BPlusTree <KeyInfo, DataValue>(options)) { Assert.IsTrue(tree.ContainsKey(k1)); Assert.IsTrue(tree.ContainsKey(k2)); } }
public void TestConcurrentCreateReadUpdateDelete8000() { BPlusTree <KeyInfo, DataValue> .OptionsV2 options = new BPlusTree <KeyInfo, DataValue> .OptionsV2( new KeyInfoSerializer(), new DataValueSerializer(), new KeyInfoComparer()); const int keysize = 16 + 4; const int valuesize = keysize + 256 + 44; options.CalcBTreeOrder(keysize, valuesize); options.FileName = TempFile.TempPath; options.CreateFile = CreatePolicy.Always; options.FileBlockSize = 8192; options.StorageType = StorageType.Disk; options.CacheKeepAliveTimeout = 10000; options.CacheKeepAliveMinimumHistory = 0; options.CacheKeepAliveMaximumHistory = 200; options.CallLevelLock = new ReaderWriterLocking(); options.LockingFactory = new LockFactory <SimpleReadWriteLocking>(); options.LockTimeout = 10000; using (BPlusTree <KeyInfo, DataValue> dictionary = new BPlusTree <KeyInfo, DataValue>(options)) using (WorkQueue work = new WorkQueue(Environment.ProcessorCount)) { Exception lastError = null; work.OnError += delegate(object o, ErrorEventArgs e) { lastError = e.GetException(); }; for (int i = 0; i < Environment.ProcessorCount; i++) { work.Enqueue(new ThreadedTest(dictionary, 1000).Run); } Assert.IsTrue(work.Complete(true, 60000)); Assert.IsNull(lastError, "Exception raised in worker: {0}", lastError); } }
private BPlusTree <C, B> .OptionsV2 GetIncOptions() { _lambdaItemSerializer = new LambdaItemSerializer(); _lambdaArraySerializer = new LambdaArraySerializer(_lambdaItemSerializer); _incBSerializer = new BSerializer(_lambdaArraySerializer); var rtv = new BPlusTree <C, B> .OptionsV2(_options.CSerializer, _incBSerializer, _options.Comparer); rtv.ReadOnly = _options.OpenReadOnly; if (_options.MaximumChildNodes >= 4 && _options.MinimumChildNodes >= 2 && _options.MaximumValueNodes >= 4 && _options.MinimumValueNodes >= 2) { rtv.MaximumChildNodes = _options.MaximumChildNodes; rtv.MinimumChildNodes = _options.MinimumChildNodes; rtv.MaximumValueNodes = _options.MaximumValueNodes; rtv.MinimumValueNodes = _options.MinimumValueNodes; } if (_options.AverageKeySize != 0 && _options.AverageValueSize != 0) { rtv.CalcBTreeOrder(_options.AverageKeySize, _options.AverageValueSize); } if (_options.FileBlockSize != 0) { rtv.FileBlockSize = _options.FileBlockSize; } rtv.CachePolicy = _options.cacheOptions.CachePolicy; if (_options.CreatePolicy != CreatePolicy.Never) { rtv.FileName = _options.FileName + ".iidx"; } rtv.CreateFile = _options.CreatePolicy; rtv.ExistingLogAction = _options.ExistingLogAction; rtv.StoragePerformance = _options.StoragePerformance; rtv.CallLevelLock = new ReaderWriterLocking(); if (_options.LockTimeout > 0) { rtv.LockTimeout = _options.LockTimeout; } switch (_options.Locking) { case LockMode.WriterOnlyLocking: rtv.LockingFactory = new LockFactory <WriterOnlyLocking>(); break; case LockMode.ReaderWriterLocking: rtv.LockingFactory = new LockFactory <ReaderWriterLocking>(); break; case LockMode.SimpleReadWriteLocking: rtv.LockingFactory = new LockFactory <SimpleReadWriteLocking>(); break; case LockMode.IgnoreLocking: rtv.LockingFactory = new IgnoreLockFactory(); break; } if (_options.cacheOptions.CacheMaximumHistory != 0 && _options.cacheOptions.CacheKeepAliveTimeOut != 0) { rtv.CacheKeepAliveMaximumHistory = _options.cacheOptions.CacheMaximumHistory; rtv.CacheKeepAliveMinimumHistory = _options.cacheOptions.CacheMinimumHistory; rtv.CacheKeepAliveTimeout = _options.cacheOptions.CacheKeepAliveTimeOut; } return(rtv); }
private static void BasicTest() { BPlusTree <double, string> .OptionsV2 options = new BPlusTree <double, string> .OptionsV2(PrimitiveSerializer.Double, PrimitiveSerializer.String); options.CalcBTreeOrder(16, 24); options.CreateFile = CreatePolicy.Always; options.FileName = System.IO.Path.GetTempFileName(); using (var tree = new BPlusTree <double, string>(options)) { // Insertion to tree. // Note: numbers are NOT inserted sorted. tree.Add(30.1, "30.2"); tree.Add(10.1, "10.2"); tree.Add(20.1, "20.2"); tree.Add(80.1, "80.2"); tree.Add(40.1, "40.2"); tree.Add(60.1, "60.2"); tree.Add(70.1, "70.2"); tree.Add(50.1, "50.2"); // To get first element. // Since sorted, first element is: 10.1 KeyValuePair <double, string> first_with_Try; tree.TryGetFirst(out first_with_Try); // Similar to previous function. var first = tree.First(); // To get last element. // Since sorted, last element is: 80.1 KeyValuePair <double, string> last_with_Try; tree.TryGetLast(out last_with_Try); // Similar to previous function. var last = tree.Last(); // Given key get the value. // Key is valid, region.e., it is available in tree. // Hence it returns: "50.2" string value_of_valid_key; tree.TryGetValue(50.1, out value_of_valid_key); // Given key get the value. // Key is invalid, region.e., it is NOT available in tree. // Hence it returns: null (default value of int) string value_of_invalid_key; tree.TryGetValue(55, out value_of_invalid_key); // The "100" key is not available and no key is available greater than // that, hence .Current should return default value of key type (0 in this case). var key_not_available = tree.EnumerateFrom(100).GetEnumerator().Current; // Runtime error //var list = tree.ToList(); // Gets an enumerator. IEnumerator <KeyValuePair <double, string> > enumerator = tree.GetEnumerator(); // Iterating through items with enumerator. // starting from first item to last. while (enumerator.MoveNext()) { var item = enumerator.Current; } // Another syntac of iterations, which is automatically // calling "GetEnumerator" function. // starting from first item to last. foreach (var item in tree) { } // Iterates through items starting from given key: 40.1 (inclusively) // and goes till the last item. foreach (var item in tree.EnumerateFrom(39.1)) { } // Iterates through items starting from given index: 2 (inclusively) // and goes till the last item. foreach (var item in tree.EnumerateFrom(tree.ElementAtOrDefault(2).Key)) { } // Iterate from an item that is NOT available in collection // to the item which is neither available. foreach (var item in tree.EnumerateRange(20.5, 40.9)) { } // Gets the item at specific index. // All return valid values, but the last one which is // refereing to an index out-of-bound; the return of this // call is the default value for key and value. var element_at_0 = tree.ElementAtOrDefault(0); var element_at_1 = tree.ElementAtOrDefault(1); var element_at_2 = tree.ElementAtOrDefault(2); var element_at_3 = tree.ElementAtOrDefault(3); var element_at_100 = tree.ElementAtOrDefault(100); using (BPlusTree <double, string> data = new BPlusTree <double, string>(options)) { bool sT1 = data.TryAdd(1, "a"); bool sF1 = data.TryAdd(1, "a"); data[1] = "did it"; bool sT2 = data.TryUpdate(1, "a"); bool sT3 = data.TryUpdate(1, "c"); bool sT4 = data.TryUpdate(1, "d", "c"); bool sF2 = data.TryUpdate(1, "f", "c"); bool equality1 = "d".Equals(data[1]); bool sT5 = data.TryUpdate(1, "a", data[1]); bool equality2 = "a".Equals(data[1]); bool sF3 = data.TryUpdate(2, "b"); string val; bool st6 = data.TryRemove(1, out val) && val == "a"; bool sF4 = data.TryRemove(2, out val); bool notEqual = val.Equals("a"); } } }