model.discriminator() 鉴频器函数

Discriminators are a schema inheritance mechanism. They enable you to have multiple models with overlapping schemas on top of the same underlying MongoDB collection.

Suppose you wanted to track different types of events in a single collection. Every event will have a timestamp, but events that represent clicked links should have a URL. You can achieve this using the model.discriminator() function. This function takes 2 parameters, a model name and a discriminator schema. It returns a model whose schema is the union of the base schema and the discriminator schema.

    var options = { discriminatorKey: 'kind' };

    var eventSchema = new mongoose.Schema({ time: Date }, options);
    var Event = mongoose.model('Event', eventSchema);

    // ClickedLinkEvent is a special type of Event that has
    // a URL.
    var ClickedLinkEvent = Event.discriminator('ClickedLink',
      new mongoose.Schema({ url: String }, options));

    // When you create a generic event, it can't have a URL field...
    var genericEvent = new Event({ time: Date.now(), url: 'google.com' });
    assert.ok(!genericEvent.url);

    // But a ClickedLinkEvent can
    var clickedEvent = new ClickedLinkEvent({ time: Date.now(), url: 'google.com' });
    assert.ok(clickedEvent.url);

Discriminators save to the Event model's collection

Suppose you created another discriminator to track events where a new user registered. These SignedUpEvent instances will be stored in the same collection as generic events and ClickedLinkEvent instances.

    var event1 = new Event({ time: Date.now() });
    var event2 = new ClickedLinkEvent({ time: Date.now(), url: 'google.com' });
    var event3 = new SignedUpEvent({ time: Date.now(), user: 'testuser' });

    var save = function(doc, callback) {
      doc.save(function(error, doc) {
        callback(error, doc);
      });
    };

    async.map([event1, event2, event3], save, function(error) {

      Event.count({}, function(error, count) {
        assert.equal(count, 3);
      });
    });

Discriminator keys

The way mongoose tells the difference between the different discriminator models is by the 'discriminator key', which is kind by default. Mongoose adds a String path called kind to your schemas that it uses to track which discriminator this document is an instance of.

    var event1 = new Event({ time: Date.now() });
    var event2 = new ClickedLinkEvent({ time: Date.now(), url: 'google.com' });
    var event3 = new SignedUpEvent({ time: Date.now(), user: 'testuser' });

    assert.ok(!event1.kind);
    assert.equal(event2.kind, 'ClickedLink');
    assert.equal(event3.kind, 'SignedUp');

Discriminators add the discriminator key to queries

Discriminator models are special; they attach the discriminator key to queries. In other words, find(), count(), aggregate(), etc. are smart enough to account for discriminators.

    var event1 = new Event({ time: Date.now() });
    var event2 = new ClickedLinkEvent({ time: Date.now(), url: 'google.com' });
    var event3 = new SignedUpEvent({ time: Date.now(), user: 'testuser' });

    var save = function(doc, callback) {
      doc.save(function(error, doc) {
        callback(error, doc);
      });
    };

    async.map([event1, event2, event3], save, function(error) {

      ClickedLinkEvent.find({}, function(error, docs) {
        assert.equal(docs.length, 1);
        assert.equal(docs[0]._id.toString(), event2._id.toString());
        assert.equal(docs[0].url, 'google.com');
      });
    });

Discriminators copy pre and post hooks

Discriminators also take their base schema's pre and post middleware. However, you can also attach middleware to the discriminator schema without affecting the base schema.

    var options = { discriminatorKey: 'kind' };

    var eventSchema = new mongoose.Schema({ time: Date }, options);
    var eventSchemaCalls = 0;
    eventSchema.pre('validate', function(next) {
      ++eventSchemaCalls;
      next();
    });
    var Event = mongoose.model('GenericEvent', eventSchema);

    var clickedLinkSchema = new mongoose.Schema({ url: String }, options);
    var clickedSchemaCalls = 0;
    clickedLinkSchema.pre('validate', function(next) {
      ++clickedSchemaCalls;
      next();
    });
    var ClickedLinkEvent = Event.discriminator('ClickedLink',
      clickedLinkSchema);

    var event1 = new ClickedLinkEvent();
    event1.validate(function() {
      assert.equal(eventSchemaCalls, 1);
      assert.equal(clickedSchemaCalls, 1);

      var generic = new Event();
      generic.validate(function() {
        assert.equal(eventSchemaCalls, 2);
        assert.equal(clickedSchemaCalls, 1);
      });
    });

处理自定义 _id 字段

A discriminator's fields are the union of the base schema's fields and the discriminator schema's fields, and the discriminator schema's fields take precedence. This behavior gets quirky when you have a custom _id field. A schema gets an _id field by default, so the base schema's _id field will get overridden by the discriminator schema's default _id field.

You can work around this by setting the _id option to false in the discriminator schema as shown below.

    var options = { discriminatorKey: 'kind' };

    // Base schema has a String _id...
    var eventSchema = new mongoose.Schema({ _id: String, time: Date }, options);
    var Event = mongoose.model('BaseEvent', eventSchema);

    var clickedLinkSchema = new mongoose.Schema({ url: String }, options);
    var ClickedLinkEvent = Event.discriminator('ChildEventBad', clickedLinkSchema);

    var event1 = new ClickedLinkEvent();
    // Woops, clickedLinkSchema overwrote the custom _id
    assert.ok(event1._id instanceof mongoose.Types.ObjectId);

    // But if you set `_id` option to false...
    clickedLinkSchema = new mongoose.Schema({ url: String }, { discriminatorKey: 'kind', _id: false });
    ClickedLinkEvent = Event.discriminator('ChildEventGood', clickedLinkSchema);

    // The custom _id from the base schema comes through
    var event2 = new ClickedLinkEvent({ _id: 'test' });
    assert.ok(event2._id.toString() === event2._id);