NeDB (Node embedded database)
Embedded persistent database for Node.js, written in Javascript, with no dependency (except npm
modules of course). You can think of it as a SQLite for Node.js projects, which
can be used with a simple require
statement. The API is a subset of MongoDB's.
Installation, tests
Module name on npm is nedb
.
npm install nedb --save
make test
API
It's a subset of MongoDB's API (the most used operations). The current API will not change, but I will add operations as they are needed. Summary of the API:
Creating/loading a database
var Datastore = require('nedb')
, db = new Datastore('path/to/datafile');
db.loadDatabase(function (err) {
});
db = {};
db.users = new Datastore('path/to/users.db');
db.robots = new Datastore('path/to/robots.db');
db.users.loadDatabase();
db.robots.loadDatabase();
Inserting documents
The native types are String
, Number
, Boolean
, Date
and null
. You can also use
arrays and subdocuments (objects). If a field is undefined
, it will not be saved (this is different from
MongoDB which transforms undefined
in null
, something I find counter-intuitive).
An _id
field will be automatically generated by NeDB. It's a 16-characters alphanumerical string that cannot be modified once it has been generated. Unlike with MongoDB, you cannot specify it (that shouldn't be a problem anyway).
Field names cannot begin by '$' or contain a '.'.
var document = { hello: 'world'
, n: 5
, today: new Date()
, nedbIsAwesome: true
, notthere: null
, notToBeSaved: undefined
, fruits: [ 'apple', 'orange', 'pear' ]
, infos: { name: 'nedb' }
};
db.insert(document, function (err, newDoc) {
});
Finding documents
Use find
to look for multiple documents matching you query, or findOne
to look for one specific document. You can select documents based on field equality or use comparison operators ($lt
, $lte
, $gt
, $gte
, $in
, $nin
, $ne
). You can also use logical operators $or
, $and
and $not
. See below for the syntax.
Basic querying
db.find({ system: 'solar' }, function (err, docs) {
});
db.find({ system: 'solar', inhabited: true }, function (err, docs) {
});
db.find({ "humans.genders": 2 }, function (err, docs) {
});
db.find({ humans: { genders: 2 } }, function (err, docs) {
});
db.find({}, function (err, docs) {
});
db.findOne({ _id: 'id1' }, function (err, doc) {
});
Comparison operators ($lt, $lte, $gt, $gte, $in, $nin, $ne)
The syntax is { field: { $op: value } }
where $op
is any comparison operator:
$lt
, $lte
: less than, less than or equal$gt
, $gte
: greater than, greater than or equal$in
: member of. value
must be an array of values$ne
, $nin
: not equal, not a member of
db.find({ "humans.genders": { $gt: 5 } }, function (err, docs) {
});
db.find({ planet: { $gt: 'Mercury' }}, function (err, docs) {
})
db.find({ planet: { $in: ['Earth', 'Jupiter'] }}, function (err, docs) {
});
Array fields
When a field in a document is an array, NeDB tries the query on every element and there is a match if at least one element matches.
db.find({ satellites: 'Phobos' }, function (err, docs) {
});
db.find({ satellites: { $lt: 'Amos' } }, function (err, docs) {
});
db.find({ satellites: { $in: ['Moon', 'Deimos'] } }, function (err, docs) {
});
Logical operators $or, $and, $not
You can combine queries using logical operators:
- For
$or
and $and
, the syntax is { $op: [query1, query2, ...] }
. - For
$not
, the syntax is { $not: query }
db.find({ $or: [{ planet: 'Earth' }, { planet: 'Mars' }] }, function (err, docs) {
});
db.find({ $not: { planet: 'Earth' } }, function (err, docs) {
});
db.find({ $or: [{ planet: 'Earth' }, { planet: 'Mars' }], inhabited: true }, function (err, docs) {
});
Updating documents
db.update(query, update, options, callback)
will update all documents matching query
according to the update
rules:
query
is the same kind of finding query you use with find
and findOne
update
specifies how the documents should be modified. It is either a new document or a set of modifiers (you cannot use both together, it doesn't make sense!)
- A new document will replace the matched docs
- The available modifiers are
$set
to change a field's value and $inc
to increment a field's value. The modifiers create the fields they need to modify if they don't exist, and you can apply them to subdocs. See examples below for the syntax
options
is an object with two possible parameters
multi
(defaults to false
) which allows the modification of several documents if set to trueupsert
(defaults to false
) if you want to insert a new document corresponding to the update
rules if your query
doesn't match anything
callback
(optional) signature: err, numReplaced, upsert
numReplaced
is the number of documents replacedupsert
is set to true if the upsert mode was chosen and a document was inserted
Note: you can't change a document's _id.
db.update({ planet: 'Jupiter' }, { planet: 'Pluton'}, {}, function (err, numReplaced) {
});
db.update({ system: 'solar' }, { $set: { system: 'solar system' } }, { multi: true }, function (err, numReplaced) {
});
db.update({ planet: 'Mars' }, { $set: { "data.satellites": 2, "data.red": true } }, {}, function () {
db.update({ planet: 'Mars' }, { $set: { date: { satellites: 3 } } }, {}, function () {
});
});
db.update({ planet: 'Pluton' }, { planet: 'Pluton', inhabited: false }, { upsert: true }, function (err, numReplaced, upsert) {
});
db.update({ planet: 'Pluton' }, { $inc: { distance: 38 } }, { upsert: true }, function () {
});
Removing documents
db.remove(query, options, callback)
will remove all documents matching query
according to options
query
is the same as the ones used for finding and updatingoptions
only one option for now: multi
which allows the removal of multiple documents if set to true. Default is falsecallback
is optional, signature: err, numRemoved
db.remove({ _id: 'id2' }, {}, function (err, numRemoved) {
});
db.remove({ system: 'solar' }, { multi: true }, function (err, numRemoved) {
});
Indexing
NeDB supports indexing. It gives a very nice speed boost and can be used to enforce a unique constraint on a field. You can index any field, including fields in nested documents using the dot notation. For now, indexes are only used for value equality, but I am planning on adding value comparison soon.
Also note that if you use a unique constraint on a field, you will only be able to save one document in which is undefined
. The second time you do that, the index will reject the document since there is already one with the undefined
value. I am working on a "sparse" option just like the MongoDB one, enabling indexes to check uniqueness only when the field is defined.
Finally, the _id
is always indexed with a unique constraint, so queries specifying a value for it are very fast.
d.ensureIndex({ fieldName: 'somefield' }, function (err) {
});
d.ensureIndex({ fieldName: 'somefield', unique: true }, function (err) {
});
d.insert({ name: 'nedb' }, function (err) {
d.insert({ name: 'nedb' }, function (err) {
});
});
Note: the ensureIndex
function creates the index synchronously, so it's best to use it at application startup. It's quite fast so it doesn't increase startup time much (35 ms for a collection containing 10,000 documents).
Performance
Speed
NeDB is not intended to be a replacement of large-scale databases such as MongoDB! Its goal is to provide you with a clean and easy way to query data and persist it to disk, for web applications that do not need lots of concurrent connections, for example a continuous integration and deployment server and desktop applications built with Node Webkit.
As such, it was not designed for speed. That said, it is still pretty fast on the expected datasets, especially if you use indexing. On my machine (3 years old, no SSD), with a collection
containing 10,000 documents:
- An insert takes 0.14 ms without indexing, 0.16 ms with indexing
- A read takes 6.4 ms without indexing, 0.02 ms with indexing
- An update takes 11 ms without indexing, 0.22 ms with indexing
- A deletion takes 10 ms without indexing, 0.14ms with indexing
You can run the simple benchmarks I use by executing the scripts in the benchmarks
folder. Run them with the --help
flag to see how they work.
A copy of the whole database is kept in memory. This is not much on the
expected kind of datasets (20MB for 10,000 2KB documents). If requested, I'll introduce an
option to not use this cache to decrease memory footprint (at the cost
of a lower speed).
Use in other services
- connect-nedb-session is a session store for
Connect and Express, backed by nedb
- If you've outgrown NeDB, switching to MongoDB won't be too hard as it is the same API. Use this utility to transfer the data from a NeDB database to a MongoDB collection
License
(The MIT License)
Copyright (c) 2013 Louis Chatriot <louis.chatriot@gmail.com>
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
'Software'), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.