Esempio n. 1
0
        public void CanPersist()
        {
            Slice key;

            using (var context = new TransactionOperationContext(Env, 1024, 1024))
                using (Slice.From(context.Allocator, "f1", out key))
                {
                    var key1 = context.GetLazyString("orders/1");

                    using (var tx = Env.WriteTransaction())
                    {
                        var tree = tx.CreateTree("Filters");
                        var ptr  = tree.DirectAdd(key, CollectionOfBloomFilters.BloomFilter.PtrSize);

                        var filter = new CollectionOfBloomFilters.BloomFilter(key, ptr, tree, writeable: true);

                        Assert.True(filter.Add(key1));
                        Assert.Equal(1, filter.Count);

                        tx.Commit();
                    }

                    using (var tx = Env.WriteTransaction())
                    {
                        var tree = tx.CreateTree("Filters");
                        var read = tree.Read("f1");

                        var filter = new CollectionOfBloomFilters.BloomFilter(key, read.Reader.Base, tree, writeable: false);

                        Assert.False(filter.Add(key1));
                        Assert.Equal(1, filter.Count);
                    }
                }
        }
Esempio n. 2
0
        public void CheckReadonly()
        {
            Slice key1, key2;

            using (var context = new TransactionOperationContext(Env, 1024, 1024))
                using (Slice.From(context.Allocator, "0000", out key1))
                    using (Slice.From(context.Allocator, "0001", out key2))
                    {
                        using (var tx = context.OpenWriteTransaction())
                        {
                            var tree = context.Transaction.InnerTransaction.CreateTree("IndexedDocs");
                            var ptr  = tree.DirectAdd(key1, CollectionOfBloomFilters.BloomFilter.PtrSize); // filter 1
                            tree.DirectAdd(key2, CollectionOfBloomFilters.BloomFilter.PtrSize);            // filter 2

                            var filter = new CollectionOfBloomFilters.BloomFilter(key1, ptr, tree, writeable: true);
                            Assert.False(filter.ReadOnly);
                            filter.MakeReadOnly();
                            Assert.True(filter.ReadOnly);

                            tx.Commit();
                        }

                        using (context.OpenWriteTransaction())
                        {
                            var collection = CollectionOfBloomFilters.Load(1024, context);
                            Assert.Equal(2, collection.Count);

                            Assert.True(collection[0].ReadOnly);
                            Assert.False(collection[1].ReadOnly);
                        }
                    }
        }