Node嵌入式数据库——NeDB

netstartMongoDB 

npminstallmongoose --save 

var mongoose = require('mongoose');    exports.index = function(req, res){     var db = mongoose.createConnection('localhost', 'test');     var schema = mongoose.Schema({ name: 'string' });    var User = db.model('User', schema);     var user = new User({ name: 'tom' });    user.save(function(err) {     if(err) // ...     res.end();   });        User.find({'name':'tom'}, function(err, docs) {       res.render('index', { title: docs});   });  };  

netstop MongoDB   scdelete MongoDB 

npminstallnedb --save 

// 加载模块 const nedb = require('nedb');   // 实例化连接对象（不带参数默认为内存数据库） const db = new nedb({   filename: '/data/save.db',   autoload: true });   // 插入单项 db.insert({   name: 'tom' }, (err, ret) => {});   // 插入多项 db.insert(   [     { name: 'tom' },     { name: 'jerry' }   ] , (err, ret) => {});   // 查询单项 db.findOne({   name: 'tom' }, (err, ret) => {});   // 查询多项 db.find({     name: {       $in: ['tom', 'jerry']     }   })   .sort({     _id: -1   })   .exec((err, ret) => {});   // 更新单项 db.update({   _id: '1' }, {   $set: {     name: 'kitty'   } }, (err, ret) => {});   // 更新多项 db.update({}, {   $set: {     name: 'kitty'   } }, {   multi: true }, (err, ret) => {});   // 删除单项 db.remove({   _id: '1' }, (err, ret) => {})   // 删除多项 db.remove({   name: 'kitty' }, {   multi: true }, (err, ret) => {}); 

[     {         name: "tom",         telephone: {             home: "123456",             mobile: "123456789",             work: "1234567890"         },         ...     },     ... ] 

// 示例 1: 内存数据库(没有必要调用loadDatabase方法) var Datastore = require('nedb'),     db = new Datastore();     // 示例 2: 本地存储需要手动调用loadDatabase方法 var Datastore = require('nedb'),     db = new Datastore({ filename: 'path/to/datafile' }); db.loadDatabase(function (err) {    // 回调函数(可选)   // Now commands will be executed });     // 示例 3: 带有autoload配置项的本地存储 var Datastore = require('nedb'),     db = new Datastore({ filename: 'path/to/datafile', autoload: true }); // You can issue commands right away     // 示例 4: 创建多个数据存储 db = {}; db.users = new Datastore('path/to/users.db'); db.robots = new Datastore('path/to/robots.db');   // 如果不配置autoload，需要加载数据库(该方法是异步的) db.users.loadDatabase(); db.robots.loadDatabase(); 

var doc = { hello: 'world'               , n: 5               , today: new Date()               , nedbIsAwesome: true               , notthere: null               , notToBeSaved: undefined  // 该字段不会被保存               , fruits: [ 'apple', 'orange', 'pear' ]               , infos: { name: 'nedb' }               };   db.insert(doc, function (err, newDoc) {  // Callback is optional   // newDoc is the newly inserted document, including its _id   // newDoc has no key called notToBeSaved since its value was undefined });   // 使用array，实现批量插入。一旦其中一个操作失败，所有改变将会回滚。 db.insert([{ a: 5 }, { a: 42 }], function (err, newDocs) {   // Two documents were inserted in the database   // newDocs is an array with these documents, augmented with their _id });   // 如果a字段有唯一性约束，该操作将会执行失败。 db.insert([{ a: 5 }, { a: 42 }, { a: 5 }], function (err) {   // err is a 'uniqueViolated' error   // The database was not modified }); 

// 数据存储集合   // { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false, satellites: ['Phobos', 'Deimos'] } // { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true, humans: { genders: 2, eyes: true } } // { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false } // { _id: 'id4', planet: 'Omicron Persei 8', system: 'futurama', inhabited: true, humans: { genders: 7 } } // { _id: 'id5', completeData: { planets: [ { name: 'Earth', number: 3 }, { name: 'Mars', number: 2 }, { name: 'Pluton', number: 9 } ] } }   // 示例1： 基本查询。可以使用正则表达式匹配字符串。使用“.”匹配对象或者数组里面的元素。   // 单字段查询 db.find({ system: 'solar' }, function (err, docs) {   // docs is an array containing documents Mars, Earth, Jupiter   // If no document is found, docs is equal to [] });   // 正则表达式查询 db.find({ planet: /ar/ }, function (err, docs) {   // docs contains Mars and Earth });   // 多条件查询 db.find({ system: 'solar', inhabited: true }, function (err, docs) {   // docs is an array containing document Earth only });   // 根据对象属性查询 db.find({ "humans.genders": 2 }, function (err, docs) {   // docs contains Earth });   // 根据数组对象属性查询 db.find({ "completeData.planets.name": "Mars" }, function (err, docs) {   // docs contains document 5 });   db.find({ "completeData.planets.name": "Jupiter" }, function (err, docs) {   // docs is empty });   db.find({ "completeData.planets.0.name": "Earth" }, function (err, docs) {   // docs contains document 5   // If we had tested against "Mars" docs would be empty because we are matching against a specific array element });     // 对象深度比较查询，不要与"."使用混淆 db.find({ humans: { genders: 2 } }, function (err, docs) {   // docs is empty, because { genders: 2 } is not equal to { genders: 2, eyes: true } });   // 查询所有结果集 db.find({}, function (err, docs) { });   // 查询某一个文档 db.findOne({ _id: 'id1' }, function (err, doc) {   // doc is the document Mars   // If no document is found, doc is null });     // 示例2： {field: {$op: value}} ($op代表任意比较运算符) // $lt, $lte: 小于，小于等于 // $gt, $gte: 大于，大于等于 // $in: 属于 // $ne, $nin: 不等于，不属于 // $exists: 取值为true或者false，用于检测文档是否具有某一字段 // $regex: 检测字符串是否与正则表达式相匹配   // $lt, $lte, $gt and $gte 只能用于数字和字符串类型 db.find({ "humans.genders": { $gt: 5 } }, function (err, docs) {   // docs contains Omicron Persei 8, whose humans have more than 5 genders (7). });   // 当进行字符串比较的时候，将使用字典序。 db.find({ planet: { $gt: 'Mercury' }}, function (err, docs) {   // docs contains Omicron Persei 8 })   // Using $in. $nin is used in the same way db.find({ planet: { $in: ['Earth', 'Jupiter'] }}, function (err, docs) {   // docs contains Earth and Jupiter });   // Using $exists db.find({ satellites: { $exists: true } }, function (err, docs) {   // docs contains only Mars });   // Using $regex with another operator db.find({ planet: { $regex: /ar/, $nin: ['Jupiter', 'Earth'] } }, function (err, docs) {   // docs only contains Mars because Earth was excluded from the match by $nin });     // 示例3： 当文档中有一个字段是数组，NeDB将首先判断查询值是否为数组，如果是数组的话将执行精确查找，然后再去判断是否存在数组比较方法(现在只支持$size和$elemMatch)。如果都没有，将会对所有元素进行查询。 // $size: 匹配数组的大小 // $elemMatch: 匹配至少一个数组元素   // 精确查找 db.find({ satellites: ['Phobos', 'Deimos'] }, function (err, docs) {   // docs contains Mars }) db.find({ satellites: ['Deimos', 'Phobos'] }, function (err, docs) {   // docs is empty })   // 使用数组比较方法 // $elemMatch 运算符将匹配数组中满足所有条件的元素 db.find({ completeData: { planets: { $elemMatch: { name: 'Earth', number: 3 } } } }, function (err, docs) {   // docs contains documents with id 5 (completeData) });   db.find({ completeData: { planets: { $elemMatch: { name: 'Earth', number: 5 } } } }, function (err, docs) {   // docs is empty });   // 在$elemMatch中使用比较运算符 db.find({ completeData: { planets: { $elemMatch: { name: 'Earth', number: { $gt: 2 } } } } }, function (err, docs) {   // docs contains documents with id 5 (completeData) });   // 注意不能使用嵌套的运算符, e.g. { $size: { $lt: 5 } } 将会抛出异常 db.find({ satellites: { $size: 2 } }, function (err, docs) {   // docs contains Mars });   db.find({ satellites: { $size: 1 } }, function (err, docs) {   // docs is empty });   // If a document's field is an array, matching it means matching any element of the array db.find({ satellites: 'Phobos' }, function (err, docs) {   // docs contains Mars. Result would have been the same if query had been { satellites: 'Deimos' } });   // This also works for queries that use comparison operators db.find({ satellites: { $lt: 'Amos' } }, function (err, docs) {   // docs is empty since Phobos and Deimos are after Amos in lexicographical order });   // This also works with the $in and $nin operator db.find({ satellites: { $in: ['Moon', 'Deimos'] } }, function (err, docs) {   // docs contains Mars (the Earth document is not complete!) });   // 示例4： 逻辑运算符 $or, $and, $not, $where // $or, $and: 并集，交集 { $op: [query1, query2, ...] } // $not: 取非 { $not: query } // $where: 条件 { $where: function () { /* object is "this", return a boolean */ } }   db.find({ $or: [{ planet: 'Earth' }, { planet: 'Mars' }] }, function (err, docs) {   // docs contains Earth and Mars });   db.find({ $not: { planet: 'Earth' } }, function (err, docs) {   // docs contains Mars, Jupiter, Omicron Persei 8 });   db.find({ $where: function () { return Object.keys(this) > 6; } }, function (err, docs) {   // docs with more than 6 properties });   // You can mix normal queries, comparison queries and logical operators db.find({ $or: [{ planet: 'Earth' }, { planet: 'Mars' }], inhabited: true }, function (err, docs) {   // docs contains Earth });   // 示例5: Projections // 在第二个参数传入projections对象，来规定返回字段。比如： {a:1, b:1}指定只返回a和b字段，{a:0, b:0}指定省略a和b这两个字段。 // _id默认返回，不需要返回设置_id: 0   // Same database as above   // Keeping only the given fields db.find({ planet: 'Mars' }, { planet: 1, system: 1 }, function (err, docs) {   // docs is [{ planet: 'Mars', system: 'solar', _id: 'id1' }] });   // Keeping only the given fields but removing _id db.find({ planet: 'Mars' }, { planet: 1, system: 1, _id: 0 }, function (err, docs) {   // docs is [{ planet: 'Mars', system: 'solar' }] });   // Omitting only the given fields and removing _id db.find({ planet: 'Mars' }, { planet: 0, system: 0, _id: 0 }, function (err, docs) {   // docs is [{ inhabited: false, satellites: ['Phobos', 'Deimos'] }] });   // Failure: using both modes at the same time db.find({ planet: 'Mars' }, { planet: 0, system: 1 }, function (err, docs) {   // err is the error message, docs is undefined });   // You can also use it in a Cursor way but this syntax is not compatible with MongoDB db.find({ planet: 'Mars' }).projection({ planet: 1, system: 1 }).exec(function (err, docs) {   // docs is [{ planet: 'Mars', system: 'solar', _id: 'id1' }] });   // Project on a nested document db.findOne({ planet: 'Earth' }).projection({ planet: 1, 'humans.genders': 1 }).exec(function (err, doc) {   // doc is { planet: 'Earth', _id: 'id2', humans: { genders: 2 } } });   // 示例6：排序和分页   // 文档集 // doc1 = { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false, satellites: ['Phobos', 'Deimos'] } // doc2 = { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true, humans: { genders: 2, eyes: true } } // doc3 = { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false } // doc4 = { _id: 'id4', planet: 'Omicron Persei 8', system: 'futurama', inhabited: true, humans: { genders: 7 } }   // No query used means all results are returned (before the Cursor modifiers) db.find({}).sort({ planet: 1 }).skip(1).limit(2).exec(function (err, docs) {   // docs is [doc3, doc1] });   // You can sort in reverse order like this db.find({ system: 'solar' }).sort({ planet: -1 }).exec(function (err, docs) {   // docs is [doc1, doc3, doc2] });   // You can sort on one field, then another, and so on like this: db.find({}).sort({ firstField: 1, secondField: -1 }) ...  // You understand how this works! 

// 文档集 // { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false } // { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true } // { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false } // { _id: 'id4', planet: 'Omicron Persia 8', system: 'futurama', inhabited: true }   // 用一个文档替换另一个文档 db.update({ planet: 'Jupiter' }, { planet: 'Pluton'}, {}, function (err, numReplaced) {   // numReplaced = 1   // The doc #3 has been replaced by { _id: 'id3', planet: 'Pluton' }   // Note that the _id is kept unchanged, and the document has been replaced   // (the 'system' and inhabited fields are not here anymore) });   // 设定一个已存字段的值 db.update({ system: 'solar' }, { $set: { system: 'solar system' } }, { multi: true }, function (err, numReplaced) {   // numReplaced = 3   // Field 'system' on Mars, Earth, Jupiter now has value 'solar system' });   // 设定一个不存在字段的值 db.update({ planet: 'Mars' }, { $set: { "data.satellites": 2, "data.red": true } }, {}, function () {   // Mars document now is { _id: 'id1', system: 'solar', inhabited: false   //                      , data: { satellites: 2, red: true }   //                      }   // Not that to set fields in subdocuments, you HAVE to use dot-notation   // Using object-notation will just replace the top-level field   db.update({ planet: 'Mars' }, { $set: { data: { satellites: 3 } } }, {}, function () {     // Mars document now is { _id: 'id1', system: 'solar', inhabited: false     //                      , data: { satellites: 3 }     //                      }     // You lost the "data.red" field which is probably not the intended behavior   }); });   // 删除一个字段 db.update({ planet: 'Mars' }, { $unset: { planet: true } }, {}, function () {   // Now the document for Mars doesn't contain the planet field   // You can unset nested fields with the dot notation of course });   // 设置upsert db.update({ planet: 'Pluton' }, { planet: 'Pluton', inhabited: false }, { upsert: true }, function (err, numReplaced, upsert) {   // numReplaced = 1, upsert = { _id: 'id5', planet: 'Pluton', inhabited: false }   // A new document { _id: 'id5', planet: 'Pluton', inhabited: false } has been added to the collection });   // If you upsert with a modifier, the upserted doc is the query modified by the modifier // This is simpler than it sounds :) db.update({ planet: 'Pluton' }, { $inc: { distance: 38 } }, { upsert: true }, function () {   // A new document { _id: 'id5', planet: 'Pluton', distance: 38 } has been added to the collection   });   // If we insert a new document { _id: 'id6', fruits: ['apple', 'orange', 'pear'] } in the collection, // let's see how we can modify the array field atomically   // $push inserts new elements at the end of the array db.update({ _id: 'id6' }, { $push: { fruits: 'banana' } }, {}, function () {   // Now the fruits array is ['apple', 'orange', 'pear', 'banana'] });   // $pop removes an element from the end (if used with 1) or the front (if used with -1) of the array db.update({ _id: 'id6' }, { $pop: { fruits: 1 } }, {}, function () {   // Now the fruits array is ['apple', 'orange']   // With { $pop: { fruits: -1 } }, it would have been ['orange', 'pear'] });   // $addToSet adds an element to an array only if it isn't already in it // Equality is deep-checked (i.e. $addToSet will not insert an object in an array already containing the same object) // Note that it doesn't check whether the array contained duplicates before or not db.update({ _id: 'id6' }, { $addToSet: { fruits: 'apple' } }, {}, function () {   // The fruits array didn't change   // If we had used a fruit not in the array, e.g. 'banana', it would have been added to the array });   // $pull removes all values matching a value or even any NeDB query from the array db.update({ _id: 'id6' }, { $pull: { fruits: 'apple' } }, {}, function () {   // Now the fruits array is ['orange', 'pear'] }); db.update({ _id: 'id6' }, { $pull: { fruits: $in: ['apple', 'pear'] } }, {}, function () {   // Now the fruits array is ['orange'] });   // $each can be used to $push or $addToSet multiple values at once // This example works the same way with $addToSet db.update({ _id: 'id6' }, { $push: { fruits: { $each: ['banana', 'orange'] } } }, {}, function () {   // Now the fruits array is ['apple', 'orange', 'pear', 'banana', 'orange'] });   // $slice can be used in cunjunction with $push and $each to limit the size of the resulting array. // A value of 0 will update the array to an empty array. A positive value n will keep only the n first elements // A negative value -n will keep only the last n elements. // If $slice is specified but not $each, $each is set to [] db.update({ _id: 'id6' }, { $push: { fruits: { $each: ['banana'], $slice: 2 } } }, {}, function () {   // Now the fruits array is ['apple', 'orange'] });   // $min/$max to update only if provided value is less/greater than current value // Let's say the database contains this document // doc = { _id: 'id', name: 'Name', value: 5 } db.update({ _id: 'id1' }, { $min: { value: 2 } }, {}, function () {   // The document will be updated to { _id: 'id', name: 'Name', value: 2 } });   db.update({ _id: 'id1' }, { $min: { value: 8 } }, {}, function () {   // The document will not be modified }); 

// 文档集 // { _id: 'id1', planet: 'Mars', system: 'solar', inhabited: false } // { _id: 'id2', planet: 'Earth', system: 'solar', inhabited: true } // { _id: 'id3', planet: 'Jupiter', system: 'solar', inhabited: false } // { _id: 'id4', planet: 'Omicron Persia 8', system: 'futurama', inhabited: true }   // 删除一条记录 // options set to {} since the default for multi is false db.remove({ _id: 'id2' }, {}, function (err, numRemoved) {   // numRemoved = 1 });   // 删除多条记录 db.remove({ system: 'solar' }, { multi: true }, function (err, numRemoved) {   // numRemoved = 3   // All planets from the solar system were removed });   // 删除所有记录 db.remove({}, { multi: true }, function (err, numRemoved) { }); 

db.ensureIndex({ fieldName: 'somefield' }, function (err) {   // If there was an error, err is not null });   // 对索引设置唯一性约束 db.ensureIndex({ fieldName: 'somefield', unique: true }, function (err) { });   // Using a sparse unique index db.ensureIndex({ fieldName: 'somefield', unique: true, sparse: true }, function (err) { });     // 使用唯一性约束制造错误，查看err的格式 db.insert({ somefield: 'nedb' }, function (err) {   // err is null   db.insert({ somefield: 'nedb' }, function (err) {     // err is { errorType: 'uniqueViolated'     //        , key: 'name'     //        , message: 'Unique constraint violated for key name' }   }); });   // 移除somefield字段的索引 db.removeIndex('somefield', function (err) { });   // Example of using expireAfterSeconds to remove documents 1 hour // after their creation (db's timestampData option is true here) db.ensureIndex({ fieldName: 'createdAt', expireAfterSeconds: 3600 }, function (err) { });   // You can also use the option to set an expiration date like so db.ensureIndex({ fieldName: 'expirationDate', expireAfterSeconds: 0 }, function (err) {   // Now all documents will expire when system time reaches the date in their   // expirationDate field }); 

// Count all planets in the solar system db.count({ system: 'solar' }, function (err, count) {   // count equals to 3 });   // Count all documents in the datastore db.count({}, function (err, count) {   // count equals to 4 });