单个模式数组中的多个模式引用 - 猫鼬

Question

你能用对几个不同模式选项的引用来填充 mongoose 模式中的数组吗？

为了澄清这个问题，假设我有以下模式：

var scenarioSchema = Schema({
  _id     : Number,
  name    : String,
  guns : []
});

var ak47 = Schema({
  _id     : Number
  //Bunch of AK specific parameters
});

var m16 = Schema({
  _id     : Number
  //Bunch of M16 specific parameters
});

我可以用一堆 ak47 或 m16 填充 guns 数组吗？我可以将 BOTH 放在同一个 guns 数组中吗？或者它是否需要在 assets 数组中填充 ref，像这样，将其限制为单个特定类型？

guns: [{ type: Schema.Types.ObjectId, ref: 'm16' }]

我知道我可以为不同的枪支类型使用单独的数组，但是随着项目的扩展，这会在模式中创建大量的额外字段，其中大部分将留空，具体取决于加载的场景。

var scenarioSchema = Schema({
  _id     : Number,
  name    : String,
  ak47s : [{ type: Schema.Types.ObjectId, ref: 'ak47' }],
  m16s: [{ type: Schema.Types.ObjectId, ref: 'm16' }]
});

回到问题，我可以将多个模式引用放在一个数组中吗？

Answer 1

您在这里寻找的是 mongoose .discriminator() 方法。这基本上允许您将不同类型的对象存储在同一个集合中，但首先将它们作为可区分的 class 个对象。

请注意，这里的 "same collection" 原则对于 .populate() 的工作方式和包含模型中引用的定义很重要。因为你真的只能指向 "one" 个模型作为参考，但是还有一些其他的魔法可以让一个模型出现很多。

示例列表：

var util = require('util'),
    async = require('async'),
    mongoose = require('mongoose'),
    Schema = mongoose.Schema;

mongoose.connect('mongodb://localhost/gunshow');

//mongoose.set("debug",true);

var scenarioSchema = new Schema({
  "name": String,
  "guns": [{ "type": Schema.Types.ObjectId, "ref": "Gun" }]
});

function BaseSchema() {
  Schema.apply(this, arguments);

  // Common Gun stuff
  this.add({
    "createdAt": { "type": Date, "default": Date.now }
  });
}

util.inherits(BaseSchema, Schema);

var gunSchema = new BaseSchema();

var ak47Schema = new BaseSchema({
  // Ak74 stuff
});

ak47Schema.methods.shoot = function() {
  return "Crack!Crack";
};

var m16Schema = new BaseSchema({
  // M16 Stuff
});

m16Schema.methods.shoot = function() {
  return "Blam!!"
};


var Scenario = mongoose.model("Scenario", scenarioSchema);

var Gun = mongoose.model("Gun", gunSchema );
var Ak47 = Gun.discriminator("Ak47", ak47Schema );
var M16 = Gun.discriminator("M16", m16Schema );


async.series(
  [
    // Cleanup
    function(callback) {
      async.each([Scenario,Gun],function(model,callback) {
        model.remove({},callback);
      },callback);
    },

    // Add some guns and add to scenario
    function(callback) {
      async.waterfall(
        [
          function(callback) {
            async.map([Ak47,M16],function(gun,callback) {
              gun.create({},callback);
            },callback);
          },
          function(guns,callback) {
            Scenario.create({
              "name": "Test",
              "guns": guns
            },callback);
          }
        ],
        callback
      );
    },

    // Get populated scenario
    function(callback) {
      Scenario.findOne().populate("guns").exec(function(err,data) {

        console.log("Populated:\n%s",JSON.stringify(data,undefined,2));

        // Shoot each gun for fun!
        data.guns.forEach(function(gun) {
          console.log("%s says %s",gun.__t,gun.shoot());
        });

        callback(err);
      });
    },

    // Show the Guns collection
    function(callback) {
      Gun.find().exec(function(err,guns) {
        console.log("Guns:\n%s", JSON.stringify(guns,undefined,2));
        callback(err);
      });
    },

    // Show magic filtering
    function(callback) {
      Ak47.find().exec(function(err,ak47) {
        console.log("Magic!:\n%s", JSON.stringify(ak47,undefined,2));
        callback(err);
      });
    }
  ],
  function(err) {
    if (err) throw err;
    mongoose.disconnect();
  }
);

并输出

Populated:
{
  "_id": "56c508069d16fab84ead921d",
  "name": "Test",
  "__v": 0,
  "guns": [
    {
      "_id": "56c508069d16fab84ead921b",
      "__v": 0,
      "__t": "Ak47",
      "createdAt": "2016-02-17T23:53:42.853Z"
    },
    {
      "_id": "56c508069d16fab84ead921c",
      "__v": 0,
      "__t": "M16",
      "createdAt": "2016-02-17T23:53:42.862Z"
    }
  ]
}
Ak47 says Crack!Crack
M16 says Blam!!
Guns:
[
  {
    "_id": "56c508069d16fab84ead921b",
    "__v": 0,
    "__t": "Ak47",
    "createdAt": "2016-02-17T23:53:42.853Z"
  },
  {
    "_id": "56c508069d16fab84ead921c",
    "__v": 0,
    "__t": "M16",
    "createdAt": "2016-02-17T23:53:42.862Z"
  }
]
Magic!:
[
  {
    "_id": "56c508069d16fab84ead921b",
    "__v": 0,
    "__t": "Ak47",
    "createdAt": "2016-02-17T23:53:42.853Z"
  }
]

您还可以取消注释清单中的 mongoose.set("debug",true) 行，以查看 mongoose 实际上是如何构建调用的。

所以这表明您可以将不同的架构应用于不同的第一个 class 对象，甚至可以像真实对象一样附加不同的方法。 Mongoose 将这些全部存储在带有附加模型的 "guns" 集合中，它将包含鉴别器引用的所有 "types"：

var Gun = mongoose.model("Gun", gunSchema );
var Ak47 = Gun.discriminator("Ak47", ak47Schema );
var M16 = Gun.discriminator("M16", m16Schema );

但每个不同的 "type" 都以特殊方式引用其自己的模型。所以你看到当 mongoose 存储和读取对象时，有一个特殊的 __t 字段告诉它要应用哪个 "model"，并因此附加模式。

作为一个例子，我们调用 .shoot() 方法，每个 model/schema 都有不同的定义。而且您仍然可以将每个单独用作查询或其他操作的模型，因为 Ak47 将自动在所有 query/upates.

中应用 __t 值

因此，虽然存储在一个集合中，但它可以看起来是多个集合，但也有将它们放在一起以进行其他有用操作的好处。这就是您可以应用您正在寻找的那种 "polymorphism" 的方法。

Answer 2

我post我对这个问题的解答。使用相同的概念 discriminators

baseSchema：包含具有多个模式的数组字段的主模型集合
itemSchema：鉴别器使用的架构父级
fizzSchema 和 buzzSchema：要在数组中使用多个模式

型号

const itemSchema = Schema({
  foo: String,
}, { discriminatorKey: 'kind', _id: false});

const fizzSchema = Schema({
  fizz: String,
}, { _id: false });

const buzzSchema = Schema({
  buzz: String,
}, { _id: false });

const baseSchema = Schema({
  items: [itemSchema],
});

baseSchema.path('items').discriminator('fizz', fizzSchema);
baseSchema.path('items').discriminator('buzz', buzzSchema);

const List = model('list', baseSchema);

测试平台

const body = {
  items: [
    { foo: 'foo'},
    { foo: 'foo', fizz: 'fizz'},
    { foo: 'foo', kind: 'fizz', fizz: 'fizz'},
    { foo: 'foo', kind: 'buzz', buzz: 'buzz'},
    { kind: 'buzz', buzz: 'buzz'},
  ]
};

const doc = new List(body);

console.log(doc);

输出

{
  items: [
    { foo: 'foo' },
    { foo: 'foo' },
    { fizz: 'fizz', foo: 'foo', kind: 'fizz' },
    { buzz: 'buzz', foo: 'foo', kind: 'buzz' },
    { buzz: 'buzz', kind: 'buzz' }
  ],
  _id: new ObjectId("626a7b1cf2aa28008d2be5ca")
}

可以在这里执行：https://replit.com/@Gabrirf/Mongoose

单个模式数组中的多个模式引用 - 猫鼬

Multiple schema references in single schema array - mongoose

javascript

mongoose

mongodb

mongoose-populate