sqlite3 vs lowdb vs levelup vs mongodb-memory-server vs pouchdb vs nedb

Package	Downloads	Stars	Size	Issues	Publish	License

sqlite3	1,618,942	6,368	3.35 MB	165	2 years ago	BSD-3-Clause
lowdb	910,537	22,203	22.9 kB	16	2 years ago	MIT
levelup	782,100	4,084	-	0	4 years ago	MIT
mongodb-memory-server	744,525	2,728	4.58 kB	18	4 days ago	MIT
pouchdb	47,916	17,349	5.53 MB	178	a year ago	Apache-2.0
nedb	38,187	13,555	-	208	9 years ago	SEE LICENSE IN LICENSE

Database Type

sqlite3:
sqlite3 is a Node.js driver for SQLite, a self-contained, serverless, and lightweight relational database. It provides a simple API for executing SQL queries and managing database files, making it a popular choice for small to medium-sized applications that require a reliable and easy-to-use database solution.
lowdb:
lowdb is a small local JSON database powered by Lodash. It is a simple and lightweight solution for storing data in JSON format, making it ideal for small projects, prototypes, or applications that need a quick and easy way to manage data without the complexity of a full database system.
levelup:
levelup is a Node.js library that provides a simple, high-level API for interacting with LevelDB and other key-value stores. It is designed for applications that require fast, low-latency access to data stored as key-value pairs.
mongodb-memory-server:
mongodb-memory-server is a Node.js package that allows you to spin up a MongoDB server in memory for testing purposes. It is particularly useful for automated tests, as it eliminates the need for a separate MongoDB instance and allows for quick setup and teardown of the database.
pouchdb:
pouchdb is an open-source JavaScript database that syncs with CouchDB and other compatible servers. It is designed for web and mobile applications, providing offline storage and synchronization capabilities, making it ideal for apps that need to work seamlessly without an internet connection.
nedb:
nedb is a lightweight, embedded NoSQL database for Node.js applications. It stores data in JSON format and provides a simple API for CRUD operations, making it easy to integrate into projects that require a fast and efficient way to manage data without the overhead of a full database server.

Use Case

sqlite3:
sqlite3 is a great choice for applications that need a lightweight relational database with full SQL support, such as mobile apps, desktop applications, and small web applications.
lowdb:
lowdb is perfect for small projects, prototypes, or applications that need a simple, file-based database without the complexity of a full database system.
levelup:
levelup is ideal for applications that require fast, low-latency access to key-value data, such as caching, real-time analytics, and lightweight data storage solutions.
mongodb-memory-server:
mongodb-memory-server is designed for testing environments where you need a temporary MongoDB instance for running automated tests without the overhead of managing a real database server.
pouchdb:
pouchdb is ideal for web and mobile applications that require offline data storage and synchronization with a remote database, providing a seamless experience for users with intermittent internet connectivity.
nedb:
nedb is suitable for small to medium-sized applications that need a simple, embedded database for quick data access, such as desktop applications, small web apps, and IoT devices.

Data Storage

sqlite3:
sqlite3 stores data in a structured format using tables, rows, and columns, allowing for complex queries and data relationships.
lowdb:
lowdb stores data in JSON format within a single file, allowing for easy read and write operations using a simple API.
levelup:
levelup stores data as key-value pairs in LevelDB or other compatible backends, providing fast read and write operations with low latency.
mongodb-memory-server:
mongodb-memory-server stores data in a MongoDB-compatible format, allowing you to perform standard MongoDB operations in an in-memory environment.
pouchdb:
pouchdb stores data in a JSON format, supporting both local storage and synchronization with remote CouchDB-compatible databases.
nedb:
nedb stores data in JSON format, either in memory or on disk, depending on the configuration, allowing for fast access and simple data management.

Code Example

sqlite3:

sqlite3 Example

const sqlite3 = require('sqlite3').verbose();
const db = new sqlite3.Database(':memory:');

db.serialize(() => {
  db.run('CREATE TABLE user (id INT, name TEXT)');
  const stmt = db.prepare('INSERT INTO user VALUES (?, ?)');
  stmt.run(1, 'Alice');
  stmt.finalize();

  db.each('SELECT * FROM user', (err, row) => {
    console.log(row);
  });
});

db.close();

lowdb:

lowdb Example

const { Low, JSONFile } = require('lowdb');

const db = new Low(new JSONFile('db.json'));

db.read();

db.data ||= { posts: [] };

db.data.posts.push({ id: 1, title: 'Lowdb is awesome' });

db.write();

console.log(db.data);

levelup:

levelup Example

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

const db = levelup(leveldown('./mydb'));

db.put('key1', 'value1', (err) => {
  if (err) return console.error('Error writing to database:', err);
  db.get('key1', (err, value) => {
    if (err) return console.error('Error reading from database:', err);
    console.log('Retrieved value:', value);
  });
});

mongodb-memory-server:

mongodb-memory-server Example

const { MongoMemoryServer } = require('mongodb-memory-server');
const mongoose = require('mongoose');

const startServer = async () => {
  const mongoServer = await MongoMemoryServer.create();
  await mongoose.connect(mongoServer.getUri());
  console.log('Connected to in-memory MongoDB');
};

startServer();

pouchdb:

pouchdb Example

const PouchDB = require('pouchdb');
const db = new PouchDB('mydb');

db.put({ _id: 'doc1', title: 'Hello, PouchDB!' }).then(() => {
  return db.get('doc1');
}).then((doc) => {
  console.log('Retrieved document:', doc);
}).catch((err) => {
  console.error('Error:', err);
});

nedb:

nedb Example

const Datastore = require('nedb');
const db = new Datastore({ filename: 'data.db', autoload: true });

db.insert({ name: 'Alice' }, (err, newDoc) => {
  if (err) console.error(err);
  console.log('Inserted:', newDoc);
});

db.find({ name: 'Alice' }, (err, docs) => {
  if (err) console.error(err);
  console.log('Found:', docs);
});

Database Type

Use Case

Data Storage

Code Example

⚙️ node-sqlite3

Features

Installing

Prebuilt binaries

Other ways to install

API

Usage

Source install

Custom file header (magic)

Building for node-webkit

Building for SQLCipher

On OS X with Homebrew

On most Linuxes (including Raspberry Pi)

Custom builds and Electron

Testing

Contributors

Acknowledgments

Changelog

License