एकल स्कीमा सरणी में एकाधिक स्कीमा संदर्भ - नेवला

आप यहां जो खोज रहे हैं वह नेवला है .discriminator() तरीका। यह मूल रूप से आपको एक ही संग्रह में विभिन्न प्रकार की वस्तुओं को संग्रहीत करने की अनुमति देता है, लेकिन उन्हें विशिष्ट प्रथम श्रेणी की वस्तुओं के रूप में रखता है।

ध्यान दें कि यहां "समान संग्रह" सिद्धांत महत्वपूर्ण है कि कैसे .populate() काम करता है और युक्त मॉडल में संदर्भ की परिभाषा। चूंकि आप वास्तव में किसी संदर्भ के लिए केवल "एक" मॉडल को इंगित कर सकते हैं, लेकिन कुछ अन्य जादू है जो एक मॉडल को कई मॉडल दिखा सकता है।

उदाहरण सूची:

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) सूची में यह देखने के लिए कि कैसे नेवला वास्तव में कॉल का निर्माण कर रहा है।

तो यह जो प्रदर्शित करता है वह यह है कि आप विभिन्न प्रथम श्रेणी की वस्तुओं के लिए अलग-अलग स्कीमा लागू कर सकते हैं, और यहां तक ​​​​कि वास्तविक वस्तुओं की तरह ही उनसे जुड़ी विभिन्न विधियों के साथ भी। नेवला इन सभी को संलग्न मॉडल के साथ एक "बंदूक" संग्रह में संग्रहीत कर रहा है, और इसमें विवेचक द्वारा संदर्भित सभी "प्रकार" शामिल होंगे:

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

लेकिन प्रत्येक अलग "प्रकार" को अपने स्वयं के मॉडल के साथ एक विशेष तरीके से संदर्भित किया जाता है। तो आप देखते हैं कि जब नेवला वस्तु को संग्रहीत और पढ़ता है, तो एक विशेष __t होता है फ़ील्ड जो यह बताता है कि कौन सा "मॉडल" लागू करना है, और इसलिए स्कीमा संलग्न है।

एक उदाहरण के रूप में हम .shoot() . कहते हैं विधि, जिसे प्रत्येक मॉडल/स्कीमा के लिए अलग-अलग परिभाषित किया गया है। और साथ ही आप अभी भी प्रत्येक को एक मॉडल के रूप में प्रश्नों या अन्य कार्यों के लिए उपयोग कर सकते हैं, क्योंकि Ak47 __t को स्वचालित रूप से लागू कर देगा सभी क्वेरी/अपेट्स में मान।

इसलिए हालांकि भंडारण एक संग्रह में है, यह कई संग्रह प्रतीत हो सकता है, लेकिन अन्य उपयोगी कार्यों के लिए उन्हें एक साथ रखने का लाभ भी है। आप जिस तरह के "बहुरूपता" की तलाश कर रहे हैं, उसे आप इस तरह से लागू कर सकते हैं।