E11000 duplicate-key-Fehler bei MongoDB/Mongoose

Habe ich ein Benutzer-Modell schema -, ein Werk-Modell schema, und eine Kritik, Modell-schema. Die Beziehung zwischen diesen schema ist einem Benutzer Einreichen können viele Werke (wie blog-posts) und Kommentare/Kritik (nennen wir Kritik) anderer Leute Beiträge (Werke).

So, wenn ein Benutzer sendet eine Kritik (es ist wie bei einem review), das ist mein post route. Ich finde die Arbeit von der id, dann erstellen Sie eine neue Kritik, Modell-Objekt, und übergeben, die .create () – Mungo-Funktion. Geht alles scheinbar gut, bis ich auf die foundWork.critiques.push(createdCritique) Linie. die Konsole log-Fehler heraus sagen:

BulkWriteError: E11000 duplicate key error collection: zapper.Kritiken-index: username_1 dup-key: { : null }

Offensichtlich, es ist zu sagen, dass es zwei Benutzernamen Schlüssel in die Objekte, und Sie sind in Konflikt mit einander, aber ich bin nicht vertraut genug mit diesem zu finden, die Wurzel des Problems und beheben Sie es in der mongoose-Modelle. Die Modelle sind unten aufgeführt. Wenn jemand helfen könnte, das würde sehr geschätzt werden.

//post route for getting the review
router.post('/:id', isLoggedIn, function(req, res) {

    Work.findById(req.params.id, function(err, foundWork) {
        if (err) {
            console.log(err);
        } else {

            //create a new critique
            var newCritique = new Critique ({
                reviewerName: {
                    id: req.user._id,
                    username: req.user.username
                },
                work: {
                    id: foundWork._id,
                    title: foundWork.title
                },
                critique : req.body.critique,
                date: Date.now(),
                rating: 0
            });

            //save new critique to db
            Critique.create(newCritique, function(err, createdCritique) {
                if (err) {
                    console.log(err)
                } else {
                    console.log("Created critique is ");
                    console.log(createdCritique);

                    //push the new critique into array of critiques of the work
                    foundWork.critiques.push(createdCritique);
                    //save to db
                    foundWork.save();                                
                }
            });
        }
    });

Benutzer-Modell:

var mongoose = require('mongoose');
var passportLocalMongoose = require('passport-local-mongoose');

var UserSchema = new mongoose.Schema({
    firstname: String,
    lastname: String,
    username: String,
    password: String,
    email: String,
    zip: String,
    bio: {
        type: String,
        default: ''
    },
    influences: {
        type: String,
        default: ''
    },
    favBooks: {
        type: String,
        default: ''
    },
    notWriting: {
        type: String,
        default: ''
    },
    favHero: {
        type: String,
        default: ''
    },
    favVillain: {
        type: String,
        default: ''
    },
    works: [
        {
            type: mongoose.Schema.Types.ObjectId,
            ref: 'Work'
        }
    ],
    critiques: [
        {
            type: mongoose.Schema.Types.ObjectId,
            ref: 'Critique'
        }
    ],
    friends: [
        {
            friendId: String,
            friendName  : String,
            friendPic: String
        }
    ],
    friendRequests: [
        {
            sendingFriendId: String,
            sendingFriendName  : String,
            sendingFriendPic: String
        }
    ],
    createdDate: {
        type: Date,
        default: Date.now
    },
    lastLogin: {
        type: Date,
        default: Date.now
    }
});

UserSchema.plugin(passportLocalMongoose);
module.exports = mongoose.model("User", UserSchema);

Arbeit Modell:

var mongoose = require('mongoose');

var WorkSchema = new mongoose.Schema({
    title: String,
    genre: String,
    workType: String,
    length: Number,
    ageRange: String,
    author: {
        id: {
            type: mongoose.Schema.Types.ObjectId,
            ref: "User"
        },
        username: String
    },
    manuscriptText: String,
    critiques: [ 
        {
            id: {
                type: mongoose.Schema.Types.ObjectId,
                ref: "Critique"
            }
        }
    ],
    ratingNumber: [Number],
    ratingSum: {
        type: Number,
        default: 0
    },
    date: {
        type: Date,
        default: Date.now
    },
    isPublic: {
        type: Boolean,
        default: true
    }
});


module.exports = mongoose.model("Work", WorkSchema);

Kritik Modell:

var mongoose = require('mongoose');
var passportLocalMongoose = require('passport-local-mongoose');

var CritiqueSchema = new mongoose.Schema({
    reviewerName: {
        id: {
            type: mongoose.Schema.Types.ObjectId,
            ref: "User"
        },
        username: String
    },
    work: {
        id: {
            type: mongoose.Schema.Types.ObjectId,
            ref: "Work"
        },
        title: String
    },
    critique: String,
    date: {
        type: Date,
        default: Date.now
    },
    rating: [Number]
});


CritiqueSchema.plugin(passportLocalMongoose);
module.exports = mongoose.model("Critique", CritiqueSchema);
InformationsquelleAutor J.G.Sable | 2018-05-01



One Reply
  1. 2

    Wenn Sie einen eindeutigen index erstellen in MongoDB, das Standardverhalten ist, dass es den index null-Werte auch.

    Das heißt, wenn Sie ein Dokument in Ihre Sammlung mit einem Benutzernamen null, Sie können nicht hinzufügen ein anderes mit einem Benutzernamen null.

    Was Sie brauchen, ist eine sparse-index, die nur Indizes der tatsächlichen Werte (und ignoriert Dokumente mit null für das Feld).

    Überprüfen Sie diesen link Es zeigt, wie eine sparse-index vs „normal“, in Mungo (index: true, vs Ersatzteil: true). Die meisten der Zeit, würden Sie wollen, sparse-Indizes.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.