Wie kann ich Auto-Inkrement-Feld in Nedb haben?

Question

Ich möchte genau wie relationalen oder Ziel-Datenbanken Autoinkrement-Bereich haben, so brauche ich eine Feld integer _id mit automatisch Feldwert, sollte Wert ein last Datensatz _id Wert wie folgt sein:

Daten:

{_id:1,name"foo"} 
{_id:2,name"bar"} 

entfernen letzter Datensatz:

{_id:1,name"foo"} 

neue Datensatz hinzufügen:

{_id:1,name"foo"} 
{_id:3,name"newbar"} 

Ich habe eine Funktion zu meinem Datenspeicher und berechnen maximal _id und plus 1 max(_id)+1 und als Feldwert festgelegt, aber es gibt ein Problem hier:

Wenn wir Autoinkrement-Feld in relationalen Datenbanken verwenden, es funktioniert wie Ich sagte und nach Ihnen remove last record reserviert es eine gelöschte Datensatznummer und neue eingefügte Datensätze fortfahren Inkrement, aber auf meine Art sagt es die _id des entfernten Datensatzes für neuen Datensatz.

Mein Code ist:

var Datastore = require('nedb'), 
localDb = new Datastore({ 
    filename: __dirname + '/dbFilePath.db', 
    autoload: true 
}); 

localDb.getMax = function(fieldName, onFind){ 
    db.find({}).sort({_id:-1}).limit(1).exec(function (err, docs) {onFind && onFind(err, docs['_id']);}); 
    return localDb; 
} 

localDb.insertAutoId = function(data, onAdd){ 
    var newIndex = 0; 
    localDb.getMax(function (err, maxValue) { 
     newIndex = maxValue+1; 

     if(!data["_id"]) 
      data["_id"] = newIndex; 

     localDb.insert(data, function (err, newDoc) { 
      onAdd && onAdd(err, newDoc); 
     }); 
    }); 
    return localDb; 
} 

Answer 1

Sie den letzten Wert des Index in der Datenbank speichern können. Etwas wie folgt aus:

var Datastore = require('nedb'); 
var db = new Datastore({ 
    filename: __dirname + '/dbFilePath.db', 
    autoload: true 
}); 

// Initialize the initial index value 
// (if it already exists in the database, it is not overwritten) 
db.insert({_id: '__autoid__', value: -1}); 

db.getAutoId = function(onFind) { 
    db.findOne({ _id: '__autoid__' }, function(err, doc) { 
    if (err) { 
     onFind && onFind(err) 
    } else { 
     // Update and returns the index value 
     db.update({ _id: '__autoid__'}, { $set: {value: ++doc.value} }, {}, 
     function(err, count) { 
      onFind && onFind(err, doc.value); 
     }); 
    } 
    }); 
    return db; 
} 

Answer 2

Eine verbesserte Antwort für NEDB wäre:

db.getAutoincrementId = function (cb) { 
    this.update(
     { _id: '__autoid__' }, 
     { $inc: { seq: 1 } }, 
     { upsert: true, returnUpdatedDocs: true }, 
     function (err, affected, autoid) { 
      cb && cb(err, autoid.seq); 
     } 
    ); 
    return this; 
}; 

, die auf die mongodb Weise entspricht:

db.getAutoincrementId = function (cb) { 
    this.findAndModify({ 
      query: { _id: '__autoid__' }, 
      update: { $inc: { seq: 1 } }, 
      new: true 
     } 
     function (err, autoid) { 
      cb && cb(err, autoid.seq); 
     } 
    ); 
    return this; 
}; 

Answer 3

Ich weiß nicht, ob es wird für Sie mehr nützlich sein Ich benutze eine Datenbank, um die nächsten IDs zu speichern, inspiriert im mysql System. Wer reserviert immer die nächste ID. Also habe ich eine Funktion erstellt, die überprüft, ob es eine ID für die db gibt, wenn nicht, fügt sie den Wert "1" hinzu, und wenn sie aktualisiert wird, sucht sie nach und ob sie existiert und die Sequenz ausführt. Dies gab mir die volle Kontrolle über meine IDs. Das Schema wäre:

{ 
name: nameDb, 
nextId: itemID 
} 

Wenn Sie möchten, dass Sie Funktionen für die Aktualisierung von Dokumenten, Versionierung erstellen usw.

Beispiel:

db.autoincrement = new Datastore({filename: 'data/autoincrement.db', autoload: true}); 

function getUniqueId(nameDb, cb) { 
    db.autoincrement.findOne({name: nameDb}, function (err, doc) { 
     if (err) { 
      throw err; 
     } else { 
      if (doc) { 
       const itemID = doc.nextId + 1; 
       db.autoincrement.update({name: nameDb}, { 
        name: nameDb, 
        nextId: itemID 
       }, {}, function (err, numReplaced) { 
        db.autoincrement.persistence.compactDatafile(); 
        if (err) { 
         throw err; 
        } else { 
         // console.log(numReplaced); 
        } 
        cb(doc.nextId); 
       }); 
      } else { 
       const data = { 
        name: nameDb, 
        nextId: 2 
       }; 

       db.autoincrement.insert(data, function (err, newDoc) { 
        if (err) { 
         throw err; 
        } else { 
         // console.log(newDoc); 
        } 
        cb(1); 
       }); 
      } 
     } 

    }); 
} 

Einsatz neues Dokument Beispiel:

 function insert(req, cb) { 
     getUniqueId("testdb", function (uniqueId) { 
      data.itemId = uniqueId; 

      db.testdb.insert(data, function (err, newDoc) { 
       if (err) { 
        cb({error: '1', message: 'error#2'}); 
        throw err; 
       } 
       cb({error: '0', message: 'Item add'}); 
      }); 

     }); 
     }