npm - rocksdb-native - Versions diffs - 0.0.0 → 0.0.1 - Mend

rocksdb-native 0.0.0 → 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (691) hide show

package/vendor/rocksdb/docs/_posts/2014-05-19-rocksdb-3-0-release.markdown DELETED Viewed

@@ -1,24 +0,0 @@
----
-title: RocksDB 3.0 release
-layout: post
-author: icanadi
-category: blog
-redirect_from:
-  - /blog/557/rocksdb-3-0-release/
----
-Check out new RocksDB release on [Github](https://github.com/facebook/rocksdb/releases/tag/3.0.fb)!
-New features in RocksDB 3.0:
-  * [Column Family support](https://github.com/facebook/rocksdb/wiki/Column-Families)
-  * [Ability to chose different checksum function](https://github.com/facebook/rocksdb/commit/0afc8bc29a5800e3212388c327c750d32e31f3d6)
-  * Deprecated ReadOptions::prefix_seek and ReadOptions::prefix
-<!--truncate-->
-Check out the full [change log](https://github.com/facebook/rocksdb/blob/3.0.fb/HISTORY.md).

package/vendor/rocksdb/docs/_posts/2014-05-22-rocksdb-3-1-release.markdown DELETED Viewed

@@ -1,20 +0,0 @@
----
-title: RocksDB 3.1 release
-layout: post
-author: icanadi
-category: blog
-redirect_from:
-  - /blog/575/rocksdb-3-1-release/
----
-Check out the new release on [Github](https://github.com/facebook/rocksdb/releases/tag/rocksdb-3.1)!
-New features in RocksDB 3.1:
-  * [Materialized hash index](https://github.com/facebook/rocksdb/commit/0b3d03d026a7248e438341264b4c6df339edc1d7)
-  * [FIFO compaction style](https://github.com/facebook/rocksdb/wiki/FIFO-compaction-style)
-We released 3.1 so fast after 3.0 because one of our internal customers needed materialized hash index.

package/vendor/rocksdb/docs/_posts/2014-06-23-plaintable-a-new-file-format.markdown DELETED Viewed

@@ -1,47 +0,0 @@
----
-title: PlainTable — A New File Format
-layout: post
-author: sdong
-category: blog
-redirect_from:
-  - /blog/599/plaintable-a-new-file-format/
----
-In this post, we are introducing "PlainTable" -- a file format we designed for RocksDB, initially to satisfy a production use case at Facebook.
-Design goals:
-1. All data stored in memory, in files stored in tmpfs/ramfs. Support DBs larger than 100GB (may be sharded across multiple RocksDB instance).
-1. Optimize for [prefix hashing](https://github.com/facebook/rocksdb/raw/gh-pages/talks/2014-03-27-RocksDB-Meetup-Siying-Prefix-Hash.pdf)
-1. Less than or around 1 micro-second average latency for single Get() or Seek().
-1. Minimize memory consumption.
-1. Queries efficiently return empty results
-<!--truncate-->
-Notice that our priority was not to maximize query performance, but to strike a balance between query performance and memory consumption. PlainTable query performance is not as good as you would see with a nicely-designed hash table, but they are of the same order of magnitude, while keeping memory overhead to a minimum.
-Since we are targeting micro-second latency, it is on the level of the number of CPU cache misses (if they cannot be parallellized, which are usually the case for index look-ups). On our target hardware with Intel CPUs of multiple sockets with NUMA, we can only allow 4-5 CPU cache misses (including costs of data TLB).
-To meet our requirements, given that only hash prefix iterating is needed, we made two decisions:
-1. to use a hash index, which is
-1. directly addressed to rows, with no block structure.
-Having addressed our latency goal, the next task was to design a very compact hash index to minimize memory consumption. Some tricks we used to meet this goal:
-1. We only use 32-bit integers for data and index offsets.The first bit serves as a flag, so we can avoid using 8-byte pointers.
-1. We never copy keys or parts of keys to index search structures. We store only offsets from which keys can be retrieved, to make comparisons with search keys.
-1. Since our file is immutable, we can accurately estimate the number of hash buckets needed.
-To make sure the format works efficiently with empty queries, we added a bloom filter check before the query. This adds only one cache miss for non-empty cases [1], but avoids multiple cache misses for most empty results queries. This is a good trade-off for use cases with a large percentage of empty results.
-These are the design goals and basic ideas of PlainTable file format. For detailed information, see [this wiki page](https://github.com/facebook/rocksdb/wiki/PlainTable-Format).
-[1] Bloom filter checks typically require multiple memory access. However, because they are independent, they usually do not make the CPU pipeline stale. In any case, we improved the bloom filter to improve data locality - we may cover this further in a future blog post.
-### Comments
-**[Siying Dong](siying.d@fb.com)**
-Does [http://rocksdb.org/feed/](http://rocksdb.org/feed/) work?

package/vendor/rocksdb/docs/_posts/2014-06-27-avoid-expensive-locks-in-get.markdown DELETED Viewed

@@ -1,89 +0,0 @@
----
-title: Avoid Expensive Locks in Get()
-layout: post
-author: leijin
-category: blog
-redirect_from:
-  - /blog/677/avoid-expensive-locks-in-get/
----
-As promised in the previous [blog post](blog/2014/05/14/lock.html)!
-RocksDB employs a multiversion concurrency control strategy. Before reading data, it needs to grab the current version, which is encapsulated in a data structure called [SuperVersion](https://reviews.facebook.net/rROCKSDB1fdb3f7dc60e96394e3e5b69a46ede5d67fb976c).
-<!--truncate-->
-At the beginning of `GetImpl()`, it used to do this:
-    <span class="zw-portion">mutex_.Lock();
-    </span>auto* s = super_version_->Ref();
-    mutex_.Unlock();
-The lock is necessary because pointer super_version_ may be updated, the corresponding SuperVersion may be deleted while Ref() is in progress.
-`Ref()` simply increases the reference counter and returns “this” pointer. However, this simple operation posed big challenges for in-memory workload and stopped RocksDB from scaling read throughput beyond 8 cores. Running 32 read threads on a 32-core CPU leads to [70% system CPU usage](https://github.com/facebook/rocksdb/raw/gh-pages/talks/2014-03-27-RocksDB-Meetup-Lei-Lockless-Get.pdf). This is outrageous!
-Luckily, we found a way to circumvent this problem by using [thread local storage](http://en.wikipedia.org/wiki/Thread-local_storage). Version change is a rare event comparable to millions of read requests. On the very first Get() request, each thread pays the mutex cost to acquire a reference to the new super version. Instead of releasing the reference after use, the reference is cached in thread’s local storage. An atomic variable is used to track global super version number. Subsequent reads simply compare the local super version number against the global super version number. If they are the same, the cached super version reference may be used directly, at no cost. If a version change is detected, mutex must be acquired to update the reference. The cost of mutex lock is amortized among millions of reads and becomes negligible.
-The code looks something like this:
-    SuperVersion* s = thread_local_->Get();
-    if (s->version_number != super_version_number_.load()) {
-      // slow path, cleanup of current super version is omitted
-      mutex_.Lock();
-      s = super_version_->Ref();
-      mutex_.Unlock();
-    }
-The result is quite amazing. RocksDB can nicely [scale to 32 cores](https://github.com/facebook/rocksdb/raw/gh-pages/talks/2014-03-27-RocksDB-Meetup-Lei-Lockless-Get.pdf) and most CPU time is spent in user land.
-Daryl Grove gives a pretty good [comparison between mutex and atomic](https://blogs.oracle.com/d/entry/the_cost_of_mutexes). However, the real cost difference lies beyond what is shown in the assembly code. Mutex can keep threads spinning on CPU or even trigger thread context switches in which all readers compete to access the critical area. Our approach prevents mutual competition by directing threads to check against a global version which does not change at high frequency, and is therefore much more cache-friendly.
-The new approach entails one issue: a thread can visit GetImpl() once but can never come back again. SuperVersion is referenced and cached in its thread local storage. All resources (e.g., memtables, files) which belong to that version are frozen. A “supervisor” is required to visit each thread’s local storage and free its resources without incurring a lock. We designed a lockless sweep using CAS (compare and switch instruction). Here is how it works:
-(1) A reader thread uses CAS to acquire SuperVersion from its local storage and to put in a special flag (SuperVersion::kSVInUse).
-(2) Upon completion of GetImpl(), the reader thread tries to return SuperVersion to local storage by CAS, expecting the special flag (SuperVersion::kSVInUse) in its local storage. If it does not see SuperVersion::kSVInUse, that means a “sweep” was done and the reader thread is responsible for cleanup (this is expensive, but does not happen often on the hot path).
-(3) After any flush/compaction, the background thread performs a sweep (CAS) across all threads’ local storage and frees encountered SuperVersion. A reader thread must re-acquire a new SuperVersion reference on its next visit.
-### Comments
-**[David Barbour](dmbarbour@gmail.com)**
-Please post an example of reading the same rocksdb concurrently.
-We are using the latest 3.0 rocksdb; however, when two separate processes
-try and open the same rocksdb for reading, only one of the open requests
-succeed. The other open always fails with “db/LOCK: Resource temporarily unavailable” So far we have not found an option that allows sharing the rocksdb for reads. An example would be most appreciated.

package/vendor/rocksdb/docs/_posts/2014-06-27-rocksdb-3-2-release.markdown DELETED Viewed

@@ -1,30 +0,0 @@
----
-title: RocksDB 3.2 release
-layout: post
-author: leijin
-category: blog
-redirect_from:
-  - /blog/647/rocksdb-3-2-release/
----
-Check out new RocksDB release on [GitHub](https://github.com/facebook/rocksdb/releases/tag/rocksdb-3.2)!
-New Features in RocksDB 3.2:
-  * PlainTable now supports a new key encoding: for keys of the same prefix, the prefix is only written once. It can be enabled through encoding_type paramter of NewPlainTableFactory()
-  * Add AdaptiveTableFactory, which is used to convert from a DB of PlainTable to BlockBasedTabe, or vise versa. It can be created using NewAdaptiveTableFactory()
-<!--truncate-->
-Public API changes:
-  * We removed seek compaction as a concept from RocksDB
-  * Add two paramters to NewHashLinkListRepFactory() for logging on too many entries in a hash bucket when flushing
-  * Added new option BlockBasedTableOptions::hash_index_allow_collision. When enabled, prefix hash index for block-based table will not store prefix and allow hash collision, reducing memory consumption

package/vendor/rocksdb/docs/_posts/2014-07-29-rocksdb-3-3-release.markdown DELETED Viewed

@@ -1,34 +0,0 @@
----
-title: RocksDB 3.3 Release
-layout: post
-author: yhciang
-category: blog
-redirect_from:
-  - /blog/1301/rocksdb-3-3-release/
----
-Check out new RocksDB release on [GitHub](https://github.com/facebook/rocksdb/releases/tag/rocksdb-3.3)!
-New Features in RocksDB 3.3:
-  * **JSON API prototype**.
-  * **Performance improvement on HashLinkList**:  We addressed performance outlier of HashLinkList caused by skewed bucket by switching data in the bucket from linked list to skip list. Add parameter threshold_use_skiplist in NewHashLinkListRepFactory().
-<!--truncate-->
-  * **More effective on storage space reclaim**:  RocksDB is now able to reclaim storage space more effectively during the compaction process.  This is done by compensating the size of each deletion entry by the 2X average value size, which makes compaction to be triggerred by deletion entries more easily.
-  * **TimeOut API to write**:  Now WriteOptions have a variable called timeout_hint_us.  With timeout_hint_us set to non-zero, any write associated with this timeout_hint_us may be aborted when it runs longer than the specified timeout_hint_us, and it is guaranteed that any write completes earlier than the specified time-out will not be aborted due to the time-out condition.
-  * **rate_limiter option**: We added an option that controls total throughput of flush and compaction. The throughput is specified in bytes/sec. Flush always has precedence over compaction when available bandwidth is constrained.
-Public API changes:
-  * Removed NewTotalOrderPlainTableFactory because it is not used and implemented semantically incorrect.

package/vendor/rocksdb/docs/_posts/2014-09-12-cuckoo.markdown DELETED Viewed

@@ -1,74 +0,0 @@
----
-title: Cuckoo Hashing Table Format
-layout: post
-author: radheshyam
-category: blog
-redirect_from:
-  - /blog/1427/new-bloom-filter-format/
----
-## Introduction
-We recently introduced a new [Cuckoo Hashing](http://en.wikipedia.org/wiki/Cuckoo_hashing) based SST file format which is optimized for fast point lookups. The new format was built for applications which require very high point lookup rates (~4Mqps) in read only mode but do not use operations like range scan, merge operator, etc. But, the existing RocksDB file formats were built to support range scan and other operations and the current best point lookup in RocksDB is 1.2 Mqps given by [PlainTable](https://github.com/facebook/rocksdb/wiki/PlainTable-Format)[ format](https://github.com/facebook/rocksdb/wiki/PlainTable-Format). This prompted a hashing based file format, which we present here. The new table format uses a cache friendly version of Cuckoo Hashing algorithm with only 1 or 2 memory accesses per lookup.
-<!--truncate-->
-Goals:
-  * Reduce memory accesses per lookup to 1 or 2
-  * Get an end to end point lookup rate of at least 4 Mqps
-  * Minimize database size
-Assumptions:
-  * Key length and value length are fixed
-  * The database is operated in read only mode
-Non-goals:
-  * While optimizing the performance of Get() operation was our primary goal, compaction and build times were secondary. We may work on improving them in future.
-Details for setting up the table format can be found in [GitHub](https://github.com/facebook/rocksdb/wiki/CuckooTable-Format).
-## Cuckoo Hashing Algorithm
-In order to achieve high lookup speeds, we did multiple optimizations, including a cache friendly cuckoo hash algorithm. Cuckoo Hashing uses multiple hash functions, _h1, ..., __hn._
-### Original Cuckoo Hashing
-To insert any new key _k_, we compute hashes of the key _h1(k), ..., __hn__(k)_. We insert the key in the first hash location that is free. If all the locations are blocked, we try to move one of the colliding keys to a different location by trying to re-insert it.
-Finding smallest set of keys to displace in order to accommodate the new key is naturally a shortest path problem in a directed graph where nodes are buckets of hash table and there is an edge from bucket _A_ to bucket _B_ if the element stored in bucket _A_ can be accommodated in bucket _B_ using one of the hash functions. The source nodes are the possible hash locations for the given key _k_ and destination is any one of the empty buckets. We use this algorithm to handle collision.
-To retrieve a key _k_, we compute hashes, _h1(k), ..., __hn__(k)_ and the key must be present in one of these locations.
-Our goal is to minimize average (and maximum) number of hash functions required and hence the number of memory accesses. In our experiments, with a hash utilization of 90%, we found that the average number of lookups is 1.8 and maximum is 3. Around 44% of keys are accommodated in first hash location and 33% in second location.
-### Cache Friendly Cuckoo Hashing
-We noticed the following two sub-optimal properties in original Cuckoo implementation:
-  * If the key is not present in first hash location, we jump to second hash location which may not be in cache. This results in many cache misses.
-  * Because only 44% of keys are located in first cuckoo block, we couldn't have an optimal prefetching strategy - prefetching all hash locations for a key is wasteful. But prefetching only the first hash location helps only 44% of cases.
-The solution is to insert more keys near first location. In case of collision in the first hash location - _h1(k)_, we try to insert it in next few buckets, _h1(k)+1, _h1(k)+2, _..., h1(k)+t-1_. If all of these _t_ locations are occupied, we skip over to next hash function _h2_ and repeat the process. We call the set of _t_ buckets as a _Cuckoo Block_. We chose _t_ such that size of a block is not bigger than a cache line and we prefetch the first cuckoo block.
-With the new algorithm, for 90% hash utilization, we found that 85% of keys are accommodated in first Cuckoo Block. Prefetching the first cuckoo block yields best results. For a database of 100 million keys with key length 8 and value length 4, the hash algorithm alone can achieve 9.6 Mqps and we are working on improving it further. End to end RocksDB performance results can be found [here](https://github.com/facebook/rocksdb/wiki/CuckooTable-Format).

package/vendor/rocksdb/docs/_posts/2014-09-12-new-bloom-filter-format.markdown DELETED Viewed

@@ -1,52 +0,0 @@
----
-title: New Bloom Filter Format
-layout: post
-author: zagfox
-category: blog
-redirect_from:
-  - /blog/1367/cuckoo/
----
-## Introduction
-In this post, we are introducing "full filter block" --- a new bloom filter format for [block based table](https://github.com/facebook/rocksdb/wiki/Rocksdb-BlockBasedTable-Format). This could bring about 40% of improvement for key query under in-memory (all data stored in memory, files stored in tmpfs/ramfs, an [example](https://github.com/facebook/rocksdb/wiki/RocksDB-In-Memory-Workload-Performance-Benchmarks) workload. The main idea behind is to generate a big filter that covers all the keys in SST file to avoid lots of unnecessary memory look ups.
-<!--truncate-->
-## What is Bloom Filter
-In brief, [bloom filter](https://github.com/facebook/rocksdb/wiki/RocksDB-Bloom-Filter) is a bits array generated for a set of keys that could tell if an arbitrary key may exist in that set.
-In RocksDB, we generate such a bloom filter for each SST file. When we conduct a query for a key, we first goes to the bloom filter block of SST file. If key may exist in filter, we goes into data block in SST file to search for the key. If not, we would return directly. So it could help speed up point look up operation a lot.
-## Original Bloom Filter Format
-Original bloom filter creates filters for each individual data block in SST file. It has complex structure (ref [here](https://github.com/facebook/rocksdb/wiki/Rocksdb-BlockBasedTable-Format#filter-meta-block)) which results in a lot of non-adjacent memory look ups.
-Here's the work flow for checking original bloom filter in block based table:
-1. Given the target key, we goes to the index block to get the "data block ID" where this key may reside.
-1. Using the "data block ID", we goes to the filter block and get the correct "offset of filter".
-1. Using the "offset of filter", we goes to the actual filter and do the checking.
-## New Bloom Filter Format
-New bloom filter creates filter for all keys in SST file and we name it "full filter". The data structure of full filter is very simple, there is just one big filter:
-    [ full filter ]
-In this way, the work flow of bloom filter checking is much simplified.
-(1) Given the target key, we goes directly to the filter block and conduct the filter checking.
-To be specific, there would be no checking for index block and no address jumping inside of filter block.
-Though it is a big filter, the total filter size would be the same as the original filter.
-One little draw back is that the new bloom filter introduces more memory consumption when building SST file because we need to buffer keys (or their hashes) before generating filter. Original filter just creates a bunch of small filters so it just buffer a small amount of keys. For full filter, we buffer hashes of all keys, which would take more memory when SST file size increases.
-## Usage & Customization
-You can refer to the document here for [usage](https://github.com/facebook/rocksdb/wiki/RocksDB-Bloom-Filter#usage-of-new-bloom-filter) and [customization](https://github.com/facebook/rocksdb/wiki/RocksDB-Bloom-Filter#customize-your-own-filterpolicy).

package/vendor/rocksdb/docs/_posts/2014-09-15-rocksdb-3-5-release.markdown DELETED Viewed

@@ -1,38 +0,0 @@
----
-title: RocksDB 3.5 Release!
-layout: post
-author: leijin
-category: blog
-redirect_from:
-  - /blog/1547/rocksdb-3-5-release/
----
-New RocksDB release - 3.5!
-**New Features**
-  1. Add include/utilities/write_batch_with_index.h, providing a utility class to query data out of WriteBatch when building it.
-  2. new ReadOptions.total_order_seek to force total order seek when block-based table is built with hash index.
-<!--truncate-->
-**Public API changes**
-  1. The Prefix Extractor used with V2 compaction filters is now passed user key to SliceTransform::Transform instead of unparsed RocksDB key.
-  2. Move BlockBasedTable related options to BlockBasedTableOptions from Options. Change corresponding JNI interface. Options affected include: no_block_cache, block_cache, block_cache_compressed, block_size, block_size_deviation, block_restart_interval, filter_policy, whole_key_filtering. filter_policy is changed to shared_ptr from a raw pointer.
-  3. Remove deprecated options: disable_seek_compaction and db_stats_log_interval
-  4. OptimizeForPointLookup() takes one parameter for block cache size. It now builds hash index, bloom filter, and block cache.
-[https://github.com/facebook/rocksdb/releases/tag/v3.5](https://github.com/facebook/rocksdb/releases/tag/rocksdb-3.5)

package/vendor/rocksdb/docs/_posts/2015-01-16-migrating-from-leveldb-to-rocksdb-2.markdown DELETED Viewed

@@ -1,112 +0,0 @@
----
-title: Migrating from LevelDB to RocksDB
-layout: post
-author: lgalanis
-category: blog
-redirect_from:
-  - /blog/1811/migrating-from-leveldb-to-rocksdb-2/
----
-If you have an existing application that uses LevelDB and would like to migrate to using RocksDB, one problem you need to overcome is to map the options for LevelDB to proper options for RocksDB. As of release 3.9 this can be automatically done by using our option conversion utility found in rocksdb/utilities/leveldb_options.h. What is needed, is to first replace `leveldb::Options` with `rocksdb::LevelDBOptions`. Then, use `rocksdb::ConvertOptions( )` to convert the `LevelDBOptions` struct into appropriate RocksDB options. Here is an example:
-<!--truncate-->
-LevelDB code:
-```c++
-#include <string>
-#include "leveldb/db.h"
-using namespace leveldb;
-int main(int argc, char** argv) {
-  DB *db;
-  Options opt;
-  opt.create_if_missing = true;
-  opt.max_open_files = 1000;
-  opt.block_size = 4096;
-  Status s = DB::Open(opt, "/tmp/mydb", &db);
-  delete db;
-}
-```
-RocksDB code:
-```c++
-#include <string>
-#include "rocksdb/db.h"
-#include "rocksdb/utilities/leveldb_options.h"
-using namespace rocksdb;
-int main(int argc, char** argv) {
-  DB *db;
-  LevelDBOptions opt;
-  opt.create_if_missing = true;
-  opt.max_open_files = 1000;
-  opt.block_size = 4096;
-  Options rocksdb_options = ConvertOptions(opt);
-  // add rocksdb specific options here
-  Status s = DB::Open(rocksdb_options, "/tmp/mydb_rocks", &db);
-  delete db;
-}
-```
-The difference is:
-```diff
--#include "leveldb/db.h"
-+#include "rocksdb/db.h"
-+#include "rocksdb/utilities/leveldb_options.h"
--using namespace leveldb;
-+using namespace rocksdb;
--  Options opt;
-+  LevelDBOptions opt;
--  Status s = DB::Open(opt, "/tmp/mydb", &db);
-+  Options rocksdb_options = ConvertOptions(opt);
-+  // add rockdb specific options here
-+
-+  Status s = DB::Open(rocksdb_options, "/tmp/mydb_rocks", &db);
-```
-Once you get up and running with RocksDB you can then focus on tuning RocksDB further by modifying the converted options struct.
-The reason why ConvertOptions is handy is because a lot of individual options in RocksDB have moved to other structures in different components. For example, block_size is not available in struct rocksdb::Options. It resides in struct rocksdb::BlockBasedTableOptions, which is used to create a TableFactory object that RocksDB uses internally to create the proper TableBuilder objects. If you were to write your application from scratch it would look like this:
-RocksDB code from scratch:
-```c++
-#include <string>
-#include "rocksdb/db.h"
-#include "rocksdb/table.h"
-using namespace rocksdb;
-int main(int argc, char** argv) {
-  DB *db;
-  Options opt;
-  opt.create_if_missing = true;
-  opt.max_open_files = 1000;
-  BlockBasedTableOptions topt;
-  topt.block_size = 4096;
-  opt.table_factory.reset(NewBlockBasedTableFactory(topt));
-  Status s = DB::Open(opt, "/tmp/mydb_rocks", &db);
-  delete db;
-}
-```
-The LevelDBOptions utility can ease migration to RocksDB from LevelDB and allows us to break down the various options across classes as it is needed.

package/vendor/rocksdb/docs/_posts/2015-02-24-reading-rocksdb-options-from-a-file.markdown DELETED Viewed

@@ -1,41 +0,0 @@
----
-title: Reading RocksDB options from a file
-layout: post
-author: lgalanis
-category: blog
-redirect_from:
-  - /blog/1883/reading-rocksdb-options-from-a-file/
----
-RocksDB options can be provided using a file or any string to RocksDB. The format is straightforward: `write_buffer_size=1024;max_write_buffer_number=2`. Any whitespace around `=` and `;` is OK. Moreover, options can be nested as necessary. For example `BlockBasedTableOptions` can be nested as follows: `write_buffer_size=1024; max_write_buffer_number=2; block_based_table_factory={block_size=4k};`. Similarly any white space around `{` or `}` is ok. Here is what it looks like in code:
-<!--truncate-->
-```c++
-#include <string>
-#include "rocksdb/db.h"
-#include "rocksdb/table.h"
-#include "rocksdb/utilities/convenience.h"
-using namespace rocksdb;
-int main(int argc, char** argv) {
-  DB *db;
-  Options opt;
-  std::string options_string =
-    "create_if_missing=true;max_open_files=1000;"
-    "block_based_table_factory={block_size=4096}";
-  Status s = GetDBOptionsFromString(opt, options_string, &opt);
-  s = DB::Open(opt, "/tmp/mydb_rocks", &db);
-  // use db
-  delete db;
-}
-```
-Using `GetDBOptionsFromString` is a convenient way of changing options for your RocksDB application without needing to resort to recompilation or tedious command line parsing.

package/vendor/rocksdb/docs/_posts/2015-02-27-write-batch-with-index.markdown DELETED Viewed

@@ -1,20 +0,0 @@
----
-title: 'WriteBatchWithIndex: Utility for Implementing Read-Your-Own-Writes'
-layout: post
-author: sdong
-category: blog
-redirect_from:
-  - /blog/1901/write-batch-with-index/
----
-RocksDB can be used as a storage engine of a higher level database. In fact, we are currently plugging RocksDB into MySQL and MongoDB as one of their storage engines. RocksDB can help with guaranteeing some of the ACID properties: durability is guaranteed by RocksDB by design; while consistency and isolation need to be enforced by concurrency controls on top of RocksDB; Atomicity can be implemented by committing a transaction's writes with one write batch to RocksDB in the end.
-<!--truncate-->
-However, if we enforce atomicity by only committing all writes in the end of the transaction in one batch, you cannot get the updated value from RocksDB previously written by the same transaction (read-your-own-write). To read the updated value, the databases on top of RocksDB need to maintain an internal buffer for all the written keys, and when a read happens they need to merge the result from RocksDB and from this buffer. This is a problem we faced when building the RocksDB storage engine in MongoDB. We solved it by creating a utility class, WriteBatchWithIndex (a write batch with a searchable index) and made it part of public API so that the community can also benefit from it.
-Before talking about the index part, let me introduce write batch first. The write batch class, `WriteBatch`, is a RocksDB data structure for atomic writes of multiple keys. Users can buffer their updates to a `WriteBatch` by calling `write_batch.Put("key1", "value1")` or `write_batch.Delete("key2")`, similar as calling RocksDB's functions of the same names. In the end, they call `db->Write(write_batch)` to atomically update all those batched operations to the DB. It is how a database can guarantee atomicity, as shown above. Adding a searchable index to `WriteBatch`, we now have `WriteBatchWithIndex`. Users can put updates to WriteBatchIndex in the same way as to `WriteBatch`. In the end, users can get a `WriteBatch` object from it and issue `db->Write()`. Additionally, users can create an iterator of a WriteBatchWithIndex, seek to any key location and iterate from there.
-To implement read-your-own-write using `WriteBatchWithIndex`, every time the user creates a transaction, we create a `WriteBatchWithIndex` attached to it. All the writes of the transaction go to the `WriteBatchWithIndex` first. When we commit the transaction, we atomically write the batch to RocksDB. When the user wants to call `Get()`, we first check if the value exists in the `WriteBatchWithIndex` and return the value if existing, by seeking and reading from an iterator of the write batch, before checking data in RocksDB. For example, here is the we implement it in MongoDB's RocksDB storage engine: [link](https://github.com/mongodb/mongo/blob/a31cc114a89a3645e97645805ba77db32c433dce/src/mongo/db/storage/rocks/rocks_recovery_unit.cpp#L245-L260). If a range query comes, we pass a DB's iterator to `WriteBatchWithIndex`, which creates a super iterator which combines the results from the DB iterator with the batch's iterator. Using this super iterator, we can iterate the DB with the transaction's own writes. Here is the iterator creation codes in MongoDB's RocksDB storage engine: [link](https://github.com/mongodb/mongo/blob/a31cc114a89a3645e97645805ba77db32c433dce/src/mongo/db/storage/rocks/rocks_recovery_unit.cpp#L266-L269). In this way, the database can solve the read-your-own-write problem by using RocksDB to handle a transaction's uncommitted writes.
-Using `WriteBatchWithIndex`, we successfully implemented read-your-own-writes in the RocksDB storage engine of MongoDB. If you also have a read-your-own-write problem, `WriteBatchWithIndex` can help you implement it quickly and correctly.

package/vendor/rocksdb/docs/_posts/2015-04-22-integrating-rocksdb-with-mongodb-2.markdown DELETED Viewed

@@ -1,16 +0,0 @@
----
-title: Integrating RocksDB with MongoDB
-layout: post
-author: icanadi
-category: blog
-redirect_from:
-  - /blog/1967/integrating-rocksdb-with-mongodb-2/
----
-Over the last couple of years, we have been busy integrating RocksDB with various services here at Facebook that needed to store key-value pairs locally. We have also seen other companies using RocksDB as local storage components of their distributed systems.
-<!--truncate-->
-The next big challenge for us is to bring RocksDB storage engine to general purpose databases. Today we have an exciting milestone to share with our community! We're running MongoDB with RocksDB in production and seeing great results! You can read more about it here: [http://blog.parse.com/announcements/mongodb-rocksdb-parse/](http://blog.parse.com/announcements/mongodb-rocksdb-parse/)
-Keep tuned for benchmarks and more stability and performance improvements.

package/vendor/rocksdb/docs/_posts/2015-06-12-rocksdb-in-osquery.markdown DELETED Viewed

@@ -1,10 +0,0 @@
----
-title: RocksDB in osquery
-layout: post
-author: icanadi
-category: lgalanis
-redirect_from:
-  - /blog/1997/rocksdb-in-osquery/
----
-Check out [this](https://code.facebook.com/posts/1411870269134471/how-rocksdb-is-used-in-osquery/) blog post by [Mike Arpaia](https://www.facebook.com/mike.arpaia) and [Ted Reed](https://www.facebook.com/treeded) about how osquery leverages RocksDB to build an embedded pub-sub system. This article is a great read and contains insights on how to properly use RocksDB.