memdown

What is memdown?

memdown is an in-memory backend for the LevelUP library, which provides a simple and efficient way to store and retrieve data in memory. It is particularly useful for testing and development purposes where persistence is not required.

What are memdown's main functionalities?

Basic Operations

This feature allows you to perform basic operations such as putting, getting, and deleting key-value pairs in the in-memory database.

const levelup = require('levelup');
const memdown = require('memdown');

const db = levelup(memdown());

// Put a value
await db.put('key', 'value');

// Get a value
const value = await db.get('key');
console.log(value); // 'value'

// Delete a value
await db.del('key');

Batch Operations

This feature allows you to perform multiple operations in a single batch, which can be more efficient than performing them individually.

const levelup = require('levelup');
const memdown = require('memdown');

const db = levelup(memdown());

// Perform batch operations
await db.batch()
  .put('key1', 'value1')
  .put('key2', 'value2')
  .del('key1')
  .write();

// Get a value
const value = await db.get('key2');
console.log(value); // 'value2'

Stream Operations

This feature allows you to create streams to read data from the database, which can be useful for processing large amounts of data efficiently.

const levelup = require('levelup');
const memdown = require('memdown');

const db = levelup(memdown());

// Put some values
await db.put('key1', 'value1');
await db.put('key2', 'value2');
await db.put('key3', 'value3');

// Create a read stream
const stream = db.createReadStream();

stream.on('data', ({ key, value }) => {
  console.log(`${key}: ${value}`);
});

stream.on('end', () => {
  console.log('Stream ended');
});

Other packages similar to memdown

leveldown

leveldown is a LevelDB backend for the LevelUP library. Unlike memdown, which stores data in memory, leveldown stores data on disk using Google's LevelDB. This makes it suitable for applications that require persistent storage.

rocksdb

rocksdb is a backend for the LevelUP library that uses Facebook's RocksDB, a high-performance, persistent key-value store. It offers better performance and more features compared to LevelDB, making it suitable for high-throughput applications.

sqlite3

sqlite3 is a backend for the LevelUP library that uses SQLite, a self-contained, serverless, and zero-configuration SQL database engine. It provides a more feature-rich and flexible storage solution compared to memdown, with support for complex queries and transactions.

README

MemDOWN

A drop-in replacement for LevelDOWN that works in-memory. Can be used as a backend for LevelUP rather than an actual LevelDB store.

Example

As of version 0.7, LevelUP allows you to pass a 'db' option when you create a new instance. This will override the default LevelDOWN store with a LevelDOWN API compatible object. MemDOWN conforms exactly to the LevelDOWN API but only performs operations in memory, so your data is discarded when the process ends or you release a reference to the database.

var levelup = require('levelup')
  // note that if multiple instances point to the same location,
  // the db will be shared, but only per process
  , db = levelup('/some/location', { db: require('memdown') })

db.put('name', 'Clint Eastwood')
db.put('dob', 'May 31, 1930')
db.put('occupation', 'Badass')

db.readStream()
  .on('data', console.log)
  .on('close', function () { console.log('Go ahead, make my day!') })

Note in this example we're not even bothering to use callbacks on our .put() methods even though they are async. We know that MemDOWN operates immediately so the data will go straight into the store.

Running our example gives:

{ key: 'dob', value: 'May 31, 1930' }
{ key: 'name', value: 'Clint Eastwood' }
{ key: 'occupation', value: 'Badass' }
Go ahead, make my day!

Global Store

Even though it's in memory, the location parameter does do something. MemDOWN has a global cache, which it uses to save databases by the path string.

So for instance if you create these two MemDOWNs:

var db1 = levelup('foo', {db: require('memdown')});
var db2 = levelup('foo', {db: require('memdown')});

...they will actually share the same data, because the 'foo' string is the same.

You may clear this global store via the MemDOWN.clearGlobalStore() function:

require('memdown').clearGlobalStore();

By default, it doesn't delete the store but replaces it with a new one, so the open instance of MemDOWN will not be affected.

clearGlobalStore takes a single parameter, which if truthy clears the store strictly by deleting each individual key:

require('memdown').clearGlobalStore(true); // delete each individual key

If you are using MemDOWN somewhere else while simultaneously clearing the global store in this way, then it may throw an error or cause unexpected results.

Browser support

See .zuul.yml for the full list of browsers that are tested in CI.

But essentially, this module requires a valid ES5-capable browser, so if you're using one that's not ES5-capable (e.g. PhantomJS, Android < 4.4, IE < 10), then you will need the es5-shim.

Testing

npm install

Then:

npm test

Or to test in the browser using Saucelabs:

npm run test-browser

Or to test locally in your browser of choice:

npm run test-browser-local

To run the linter:

npm run lint

To check code coverage:

npm run coverage

Licence

MemDOWN is Copyright (c) 2013-2015 Rod Vagg @rvagg and licensed under the MIT licence. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.