我无法“插入”我的阵列。下面的代码在我的answers数组中创建了重复项，我绝对不希望这样做，并且现在看来$push无法正常工作。我尝试使用在SO上看到的不同方法已有一段时间了，但是没有一种方法适合我。使用此网络应用程序，用户可以在网站上查看问题并以"is"或“否”的response进行响应，并且他们可以随时更改(更新)其response，这意味着在数据库在不同的时间。如何解决这个问题？

var QuestionSchema = Schema ({
    title       :String,
    admin       :{type: String, ref: 'User'},
    answers     :[{type:  Schema.Types.Mixed, ref: 'Answer'}]
});

var AnswerSchema = Schema ({
    _question   :{type: ObjectId, ref: 'Question'},
    employee    :{type: String, ref: 'User'},
    response    :String,
    isAdmin     :{type: Boolean, ref: 'User'}
})

var UserSchema = Schema({
    username    : String,
    isAdmin     : {type: Boolean, default: false}
});

module.exports = mongoose.model('Question', QuestionSchema);
module.exports = mongoose.model('Answer', AnswerSchema);
module.exports = mongoose.model('User', UserSchema);


           Question.update(
                {_id: req.body.id},
                {$push: {answers: {_question: req.body.id, 
                                    employee: req.body.employee, 
                                    response: req.body.response, //this variable changes (yes/no/null)
                                     isAdmin: req.body.isAdmin}}},
                {safe: true, upsert: true},
                function(err, model) {

                }
            );

最佳答案

正如我所看到的，您似乎有些困惑，它反射(reflect)在您的模式中。您似乎没有完全掌握“嵌入式”和“引用”之间的区别，因为您的架构实际上是这两种技术的无效“混搭”。

可能最好将它们引导给您。

嵌入式模型

因此，实际上您应该拥有类似以下内容，而不是您已定义的模式:

var QuestionSchema = Schema ({
    title       :String,
    admin       :{type: String, ref: 'User'},
    answers     :[AnswerSchema]
});

var AnswerSchema = Schema ({
    employee    :{type: String, ref: 'User'},
    response    :String,
    isAdmin     :{type: Boolean, ref: 'User'}
})

mongoose.model('Question', questionSchema);

Question.update(
  { 
    "_id": req.body.id,
    "answers.employee": { "$ne": req.body.employee },
    }
  },
  { "$push": {
    "answers": { 
      "employee": req.body.employee, 
      "response": req.body.response,
      "isAdmin": req.body.isAdmin
    }
  }},
  function(err, numAffected) {

  });

Question.collection.bulkWrite(
  [
    { "updateOne": { 
      "filter": {
        "_id": req.body.id,
        "answers.employee": req.body.employee,
      },
      "update": {
        "$set": {
          "answers.$.response": req.body.response,
        }
      }
    }},
    { "updateOne": { 
      "filter": {
        "_id": req.body.id,
        "answers.employee": { "$ne": req.body.employee },
      },
      "update": {
        "$push": {
          "answers": { 
            "employee": req.body.employee, 
            "response": req.body.response,
            "isAdmin": req.body.isAdmin
          }
        }
      }
    }}
  ],
  function(err, writeResult) {

  }
);

var QuestionSchema = Schema ({
    title       :String,
    admin       :{type: String, ref: 'User'},
    answers     :[{ type: Schema.Types.ObjectId, ref: 'Answer' }]
});

var AnswerSchema = Schema ({
    _question   :{type: ObjectId, ref: 'Question'},
    employee    :{type: String, ref: 'User'},
    response    :String,
    isAdmin     :{type: Boolean, ref: 'User'}
})

mongoose.model('Answer', answerSchema);
mongoose.model('Question', questionSchema);

    employee    :{type: String, ref: 'User'},
    isAdmin     :{type: Boolean, ref: 'User'}

Answer.update(
  { "_question": req.body.id, "employee": req.body.employee },
  { 
    "$set": {
      "response": req.body.reponse
    },
    "$setOnInsert": {
      "isAdmin": req.body.isAdmin
    }
  },
  { "upsert": true }
).then(resp => {
  if ( resp.hasOwnProperty("upserted") ) {
    return Question.update(
      { "_id": req.body.id, "answers": { "$ne": resp.upserted[0]._id  },
      { "$push": { "answers": resp.upserted[0]._id  } }
    ).exec()
  }
  return;
}).then(resp => {
   // either undefined where it was not an upsert or 
   // the update result from Question where it was
}).catch(err => { 
   // something
})

{
  "name": "colex",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "async": "^2.4.1",
    "mongodb": "^2.2.29",
    "mongoose": "^4.10.7"
  }
}

const async = require('async'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema,
    ObjectId = require('mongodb').ObjectID

mongoose.Promise = global.Promise;
mongoose.set('debug',true);
mongoose.connect('mongodb://localhost/coltest');

const userSchema = new Schema({
  username: String,
  isAdmin: { type: Boolean, default: false }
});

const answerSchemaA = new Schema({
  employee: { type: Schema.Types.ObjectId, ref: 'User' },
  response: String,
});

const answerSchemaB = new Schema({
  question: { type: Schema.Types.ObjectId, ref: 'QuestionB' },
  employee: { type: Schema.Types.ObjectId, ref: 'User' },
  response: String,
});

const questionSchemaA = new Schema({
  title: String,
  admin: { type: Schema.Types.ObjectId, ref: 'User' },
  answers: [answerSchemaA]
});

const questionSchemaB = new Schema({
  title: String,
  admin: { type: Schema.Types.ObjectId, ref: 'User' },
  answers: [{ type: Schema.Types.ObjectId, ref: 'AnswerB' }]
});

const User = mongoose.model('User', userSchema);

const AnswerB = mongoose.model('AnswerB', answerSchemaB);

const QuestionA = mongoose.model('QuestionA', questionSchemaA);
const QuestionB = mongoose.model('QuestionB', questionSchemaB);


async.series(
  [
    // Clear data
    (callback) => async.each(mongoose.models,(model,callback) =>
      model.remove({},callback),callback),

    // Create some data
    (callback) =>
      async.each([
        {
          "model": "User",
          "object": {
            "_id": "594a322619ddbd437193c759",
            "name": "Admin",
            "isAdmin": true
          }
        },
        {
          "model": "User",
          "object": {
            "_id":  "594a323919ddbd437193c75a",
            "name": "Bill"
          }
        },
        {
          "model": "User",
          "object": {
            "_id":  "594a327b19ddbd437193c75b",
            "name": "Ted"
          }
        },
        {
          "model": "QuestionA",
          "object": {
            "_id": "594a32f719ddbd437193c75c",
            "admin": "594a322619ddbd437193c759",
            "title": "Question A Model"
          }
        },
        {
          "model": "QuestionB",
          "object": {
            "_id": "594a32f719ddbd437193c75c",
            "admin": "594a322619ddbd437193c759",
            "title": "Question B Model"
          }
        }
      ],(data,callback) => mongoose.model(data.model)
        .create(data.object,callback),
      callback
    ),

    // Submit Answers for Users - Question A
    (callback) =>
      async.eachSeries(
        [
          {
            "_id": "594a32f719ddbd437193c75c",
            "employee": "594a323919ddbd437193c75a",
            "response": "Bills Answer"
          },
          {
            "_id": "594a32f719ddbd437193c75c",
            "employee": "594a327b19ddbd437193c75b",
            "response": "Teds Answer"
          },
          {
            "_id": "594a32f719ddbd437193c75c",
            "employee": "594a323919ddbd437193c75a",
            "response": "Bills Changed Answer"
          }
        ].map(d => ([
          { "updateOne": {
            "filter": {
              "_id": ObjectId(d._id),
              "answers.employee": ObjectId(d.employee)
            },
            "update": {
              "$set": { "answers.$.response": d.response }
            }
          }},
          { "updateOne": {
            "filter": {
              "_id": ObjectId(d._id),
              "answers.employee": { "$ne": ObjectId(d.employee) }
            },
            "update": {
              "$push": {
                "answers": {
                  "employee": ObjectId(d.employee),
                  "response": d.response
                }
              }
            }
          }}
        ])),
        (data,callback) => QuestionA.collection.bulkWrite(data,callback),
        callback
      ),

    // Submit Answers for Users - Question A
    (callback) =>
      async.eachSeries(
        [
          {
            "_id": "594a32f719ddbd437193c75c",
            "employee": "594a323919ddbd437193c75a",
            "response": "Bills Answer"
          },
          {
            "_id": "594a32f719ddbd437193c75c",
            "employee": "594a327b19ddbd437193c75b",
            "response": "Teds Anwser"
          },
          {
            "_id": "594a32f719ddbd437193c75c",
            "employee": "594a327b19ddbd437193c75b",
            "response": "Ted Changed it"
          }
        ],
        (data,callback) => {
          AnswerB.update(
            { "question": data._id, "employee": data.employee },
            { "$set": { "response": data.response } },
            { "upsert": true }
          ).then(resp => {
            console.log(resp);
            if (resp.hasOwnProperty("upserted")) {
              return QuestionB.update(
                { "_id": data._id, "employee": { "$ne": data.employee } },
                { "$push": { "answers": resp.upserted[0]._id } }
              ).exec()
            }
            return;
          }).then(() => callback(null))
          .catch(err => callback(err))
        },
        callback
      )
  ],
  (err) => {
    if (err) throw err;
    mongoose.disconnect();
  }
)

关于node.js - 在不创建重复项的情况下使用阵列进行Upsert，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44660284/