model.discriminator() 函数 - 图1mongoose

model.discriminator() 函数 - 图2mongoose

[

model.discriminator() 函数 ](#model-discriminator-函数)

Discriminator 是一种 schema 继承机制。 他允许你在相同的底层 MongoDB collection 上 使用部分重叠的 schema 建立多个 model。

假设你要在单个 collection 中记录多种 event， 每个 event 都有时间戳字段，但是 click 事件还有 URL 字段， 这时你可以用 model.discriminator() 实现上述要求。 此函数接受 2 个参数，model 名称和 discriminator schema， 返回的 model 结合了原 model 的 schema 和 discriminator schema。

  2.     var options = {discriminatorKey: 'kind'};
  4.     var eventSchema = new mongoose.Schema({time: Date}, options);
  5.     var Event = mongoose.model('Event', eventSchema);
  7.     // ClickedLinkEvent 是一个有 URL 的特别 event
  8.     var ClickedLinkEvent = Event.discriminator('ClickedLink',
  9.       new mongoose.Schema({url: String}, options));
  11.     // 当你创建通用 event，他将没有 URL 字段...
  12.     var genericEvent = new Event({time: Date.now(), url: 'google.com'});
  13.     assert.ok(!genericEvent.url);
  15.     // 但是 ClickedLinkEvent 可以有
  16.     var clickedEvent =
  17.       new ClickedLinkEvent({time: Date.now(), url: 'google.com'});
  18.     assert.ok(clickedEvent.url);

[

Discriminator 储存在 Event model 的 collection ](#discriminator-储存在-event-model-的-collection)

现在假设你要创建另一个 discriminator，记录用户注册 event。 SignedUpEvent 实例将跟 通用 events 和 ClickedLinkEvent 实例 一样储存在同一个 collection。

  2.     var event1 = new Event({time: Date.now()});
  3.     var event2 = new ClickedLinkEvent({time: Date.now(), url: 'google.com'});
  4.     var event3 = new SignedUpEvent({time: Date.now(), user: 'testuser'});
  6.     var save = function (doc, callback) {
  7.       doc.save(function (error, doc) {
  8.         callback(error, doc);
  9.       });
  10.     };
  12.     async.map([event1, event2, event3], save, function (error) {
  14.       Event.count({}, function (error, count) {
  15.         assert.equal(count, 3);
  16.       });
  17.     });

[

Discriminator keys ](#discriminator-keys)

Mongoose 通过 'discriminator key' 识别两个不同的 discriminator， 这个值默认是 __t 。Mongoose 自动在你的 schema 添加 __t 字段， 记录你的 document 是哪个 discriminator 的实例。

  2.     var event1 = new Event({time: Date.now()});
  3.     var event2 = new ClickedLinkEvent({time: Date.now(), url: 'google.com'});
  4.     var event3 = new SignedUpEvent({time: Date.now(), user: 'testuser'});
  6.     assert.ok(!event1.__t);
  7.     assert.equal(event2.__t, 'ClickedLink');
  8.     assert.equal(event3.__t, 'SignedUp');

[

Discriminator 在查询中添加 discriminator key ](#discriminator-在查询中添加-discriminator-key)

Discriminator model 的特别之处在于：他们会把 discriminator key 附到 query 上。换句话说，find(), count(), aggregate() 等方法 都能适配 discriminators。

  2.     var event1 = new Event({time: Date.now()});
  3.     var event2 = new ClickedLinkEvent({time: Date.now(), url: 'google.com'});
  4.     var event3 = new SignedUpEvent({time: Date.now(), user: 'testuser'});
  6.     var save = function (doc, callback) {
  7.       doc.save(function (error, doc) {
  8.         callback(error, doc);
  9.       });
  10.     };
  12.     async.map([event1, event2, event3], save, function (error) {
  14.       ClickedLinkEvent.find({}, function (error, docs) {
  15.         assert.equal(docs.length, 1);
  16.         assert.equal(docs[0]._id.toString(), event2._id.toString());
  17.         assert.equal(docs[0].url, 'google.com');
  18.       });
  19.     });

[

Discriminator 复制 pre / post 钩子 ](#discriminator-复制-pre-/-post-钩子)

Discriminator 会继承他的基础 schema 的 pre 和 post 中间件。 不过，你也可以为 discriminator 添加中间件，这不回影响到基础 schema。

  2.     var options = {discriminatorKey: 'kind'};
  4.     var eventSchema = new mongoose.Schema({time: Date}, options);
  5.     var eventSchemaCalls = 0;
  6.     eventSchema.pre('validate', function (next) {
  7.       ++eventSchemaCalls;
  8.       next();
  9.     });
  10.     var Event = mongoose.model('GenericEvent', eventSchema);
  12.     var clickedLinkSchema = new mongoose.Schema({url: String}, options);
  13.     var clickedSchemaCalls = 0;
  14.     clickedLinkSchema.pre('validate', function (next) {
  15.       ++clickedSchemaCalls;
  16.       next();
  17.     });
  18.     var ClickedLinkEvent = Event.discriminator('ClickedLinkEvent',
  19.       clickedLinkSchema);
  21.     var event1 = new ClickedLinkEvent();
  22.     event1.validate(function() {
  23.       assert.equal(eventSchemaCalls, 1);
  24.       assert.equal(clickedSchemaCalls, 1);
  26.       var generic = new Event();
  27.       generic.validate(function() {
  28.         assert.equal(eventSchemaCalls, 2);
  29.         assert.equal(clickedSchemaCalls, 1);
  30.       });
  31.     });

[

处理自定义 _id 字段 ](#处理自定义-_id-字段)

Discriminator 的字段是基础 schema 加 discriminator schema ， 并且以 discriminator schema 的字段优先。 但有一个例外，_id 字段。

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

  2.     var options = {discriminatorKey: 'kind'};
  4.     // 基础 schema 有字符串格式的 `_id` 字段和 Data 格式的 `time` 字段...
  5.     var eventSchema = new mongoose.Schema({_id: String, time: Date},
  6.       options);
  7.     var Event = mongoose.model('BaseEvent', eventSchema);
  9.     var clickedLinkSchema = new mongoose.Schema({
  10.       url: String,
  11.       time: String
  12.     }, options);
  13.     // 但是 Discriminator schema 有字符串格式的 `time`，并且有
  14.     // 隐式添加的 ObjectId 格式的 `_id`
  15.     assert.ok(clickedLinkSchema.path('_id'));
  16.     assert.equal(clickedLinkSchema.path('_id').instance, 'ObjectID');
  17.     var ClickedLinkEvent = Event.discriminator('ChildEventBad',
  18.       clickedLinkSchema);
  20.     var event1 = new ClickedLinkEvent({ _id: 'custom id', time: '4pm' });
  21.     // 问题来了，clickedLinkSchema 重写了 `time` 路径，但是**没有**
  22.     // 重写 `_id` 路径，因为已经隐式添加（没看懂）
  23.     assert.ok(typeof event1._id === 'string');
  24.     assert.ok(typeof event1.time === 'string');

[

discriminator 与 Model.create() ](#discriminator-与-model-create)

当你使用 Model.create()，Mongoose 会自动帮你适配 discriminator key ~

  2.     var Schema = mongoose.Schema;
  3.     var shapeSchema = new Schema({
  4.       name: String
  5.     }, { discriminatorKey: 'kind' });
  7.     var Shape = db.model('Shape', shapeSchema);
  9.     var Circle = Shape.discriminator('Circle',
  10.       new Schema({ radius: Number }));
  11.     var Square = Shape.discriminator('Square',
  12.       new Schema({ side: Number }));
  14.     var shapes = [
  15.       { name: 'Test' },
  16.       { kind: 'Circle', radius: 5 },
  17.       { kind: 'Square', side: 10 }
  18.     ];
  19.     Shape.create(shapes, function(error, shapes) {
  20.       assert.ifError(error);
  21.       // 重点看这里
  22.       assert.ok(shapes[0] instanceof Shape);
  23.       assert.ok(shapes[1] instanceof Circle);
  24.       assert.equal(shapes[1].radius, 5);
  25.       assert.ok(shapes[2] instanceof Square);
  26.       assert.equal(shapes[2].side, 10);
  27.     });

[

数组中的嵌套 discriminator ](#数组中的嵌套-discriminator)

你也可以为嵌套文档数组定义 discriminator。 嵌套 discriminator 的特点是：不同 discriminator 类型储存在相同的文档而不是同一个 mongoDB collection。 换句话说，嵌套 discriminator 让你 在同一个数组储存符合不同 schema 的子文档。

最佳实践：确保你声明了钩子再使用他们。 你不应当在调用 discriminator() 之后调用 pre() 或 post()

  2.     var eventSchema = new Schema({ message: String },
  3.       { discriminatorKey: 'kind', _id: false });
  5.     var batchSchema = new Schema({ events: [eventSchema] });
  7.     // `batchSchema.path('events')` gets the mongoose `DocumentArray`
  8.     var docArray = batchSchema.path('events');
  10.     // 这个 `events` 数组可以包含 2 种不同的 event 类型，
  11.     // 'clicked' event that requires an element id that was clicked...
  12.     var clickedSchema = new Schema({
  13.       element: {
  14.         type: String,
  15.         required: true
  16.       }
  17.     }, { _id: false });
  18.     // 确定在调用 `discriminator()` **之前**
  19.     // 对 `eventSchema` 和 `clickedSchema` 赋予钩子
  20.     var Clicked = docArray.discriminator('Clicked', clickedSchema);
  22.     // ... and a 'purchased' event that requires the product that was purchased.
  23.     var Purchased = docArray.discriminator('Purchased', new Schema({
  24.       product: {
  25.         type: String,
  26.         required: true
  27.       }
  28.     }, { _id: false }));
  30.     var Batch = db.model('EventBatch', batchSchema);
  32.     // Create a new batch of events with different kinds
  33.     var batch = {
  34.       events: [
  35.         { kind: 'Clicked', element: '#hero', message: 'hello' },
  36.         { kind: 'Purchased', product: 'action-figure-1', message: 'world' }
  37.       ]
  38.     };
  40.     Batch.create(batch).
  41.       then(function(doc) {
  42.         assert.equal(doc.events.length, 2);
  44.         assert.equal(doc.events[0].element, '#hero');
  45.         assert.equal(doc.events[0].message, 'hello');
  46.         assert.ok(doc.events[0] instanceof Clicked);
  48.         assert.equal(doc.events[1].product, 'action-figure-1');
  49.         assert.equal(doc.events[1].message, 'world');
  50.         assert.ok(doc.events[1] instanceof Purchased);
  52.         doc.events.push({ kind: 'Purchased', product: 'action-figure-2' });
  53.         return doc.save();
  54.       }).
  55.       then(function(doc) {
  56.         assert.equal(doc.events.length, 3);
  58.         assert.equal(doc.events[2].product, 'action-figure-2');
  59.         assert.ok(doc.events[2] instanceof Purchased);
  61.         done();
  62.       }).
  63.       catch(done);

[

检索数组中的嵌套 discriminator ](#检索数组中的嵌套-discriminator)

检索嵌套 discriminator

  2.     var singleEventSchema = new Schema({ message: String },
  3.       { discriminatorKey: 'kind', _id: false });
  5.     var eventListSchema = new Schema({ events: [singleEventSchema] });
  7.     var subEventSchema = new Schema({
  8.        sub_events: [singleEventSchema]
  9.     }, { _id: false });
  11.     var SubEvent = subEventSchema.path('sub_events').discriminator('SubEvent', subEventSchema)
  12.     eventListSchema.path('events').discriminator('SubEvent', subEventSchema);
  14.     var Eventlist = db.model('EventList', eventListSchema);
  16.     // Create a new batch of events with different kinds
  17.     var list = {
  18.       events: [
  19.         { kind: 'SubEvent', sub_events: [{kind:'SubEvent', sub_events:[], message:'test1'}], message: 'hello' },
  20.         { kind: 'SubEvent', sub_events: [{kind:'SubEvent', sub_events:[{kind:'SubEvent', sub_events:[], message:'test3'}], message:'test2'}], message: 'world' }
  21.       ]
  22.     };
  24.     Eventlist.create(list).
  25.       then(function(doc) {
  26.         assert.equal(doc.events.length, 2);
  28.         assert.equal(doc.events[0].sub_events[0].message, 'test1');
  29.         assert.equal(doc.events[0].message, 'hello');
  30.         assert.ok(doc.events[0].sub_events[0] instanceof SubEvent);
  32.         assert.equal(doc.events[1].sub_events[0].sub_events[0].message, 'test3');
  33.         assert.equal(doc.events[1].message, 'world');
  34.         assert.ok(doc.events[1].sub_events[0].sub_events[0] instanceof SubEvent);
  36.         doc.events.push({kind:'SubEvent', sub_events:[{kind:'SubEvent', sub_events:[], message:'test4'}], message:'pushed'});
  37.         return doc.save();
  38.       }).
  39.       then(function(doc) {
  40.         assert.equal(doc.events.length, 3);
  42.         assert.equal(doc.events[2].message, 'pushed');
  43.         assert.ok(doc.events[2].sub_events[0] instanceof SubEvent);
  45.         done();
  46.       }).
  47.       catch(done);