模型

模型是一个类，是您与 MongoDB 交互的主要工具。模型的实例称为 文档。

在 Mongoose 中，术语“模型”指的是 mongoose.Model 类的子类。您不应该直接使用 mongoose.Model 类。 mongoose.model() 和 connection.model() 函数创建 mongoose.Model 的子类，如下所示。

示例

// `UserModel` is a "Model", a subclass of `mongoose.Model`.
const UserModel = mongoose.model('User', new Schema({ name: String }));

// You can use a Model to create new documents using `new`:
const userDoc = new UserModel({ name: 'Foo' });
await userDoc.save();

// You also use a model to create queries:
const userFromDb = await UserModel.findOne({ name: 'Foo' });

创建一个 Query 并指定 $where 条件。

有时您需要使用 JavaScript 表达式查询 mongodb 中的内容。您可以通过 find({ $where: javascript }) 执行此操作，或者可以通过 Query 链或从您的 mongoose 模型中使用 mongoose 快捷方法 $where。

Blog.$where('this.username.indexOf("val") !== -1').exec(function (err, docs) {});

在模型的集合上执行 聚合。

如果传递了 callback，则执行 aggregate 并返回 Promise。如果未传递回调，则返回 aggregate 本身。

此函数触发以下中间件。

• aggregate()

示例

// Find the max balance of all accounts
const res = await Users.aggregate([
  { $group: { _id: null, maxBalance: { $max: '$balance' }}},
  { $project: { _id: 0, maxBalance: 1 }}
]);

console.log(res); // [ { maxBalance: 98000 } ]

// Or use the aggregation pipeline builder.
const res = await Users.aggregate().
  group({ _id: null, maxBalance: { $max: '$balance' } }).
  project('-id maxBalance').
  exec();
console.log(res); // [ { maxBalance: 98 } ]

注意

• Mongoose **不会** 将聚合管道转换为模型的模式，因为 $project 和 $group 运算符允许在管道的任何阶段重新定义文档的“形状”，这可能会导致文档处于不兼容的格式。您可以使用 mongoose-cast-aggregation 插件 为聚合管道启用最小转换。
• 返回的文档是纯 javascript 对象，而不是 mongoose 文档（因为可以返回任何形状的文档）。

关于聚合的更多信息

• Mongoose Aggregate
• Mongoose Aggregate 简介
• MongoDB 聚合文档

将默认值应用于给定的文档或 POJO。

将此模型的虚拟值应用于给定的 POJO。虚拟值以 POJO 作为上下文 this 执行。

示例

const userSchema = new Schema({ name: String });
userSchema.virtual('upper').get(function() { return this.name.toUpperCase(); });
const User = mongoose.model('User', userSchema);

const obj = { name: 'John' };
User.applyVirtuals(obj);
obj.name; // 'John'
obj.upper; // 'JOHN', Mongoose applied the return value of the virtual to the given object

获取文档数组，获取更改，并根据文档是新的，还是有更改，在数据库中插入或更新文档。

bulkSave 在后台使用 bulkWrite，因此它在处理大量文档（10K+）时非常有用

bulkSave() 在以下情况下会抛出错误

• 提供的文档之一验证失败。在这种情况下，bulkSave() 不会发送 bulkWrite()，而是抛出第一个验证错误。
• bulkWrite() 失败（例如，由于无法连接到 MongoDB 或由于重复键错误）
• bulkWrite() 未插入或更新 **任何** 文档。在这种情况下，bulkSave() 将抛出 DocumentNotFound 错误。

请注意，如果仅成功执行了一些 save() 调用，bulkSave() **不会** 抛出错误。

将多个 insertOne、updateOne、updateMany、replaceOne、deleteOne 和/或 deleteMany 操作作为单个命令发送到 MongoDB 服务器。这比发送多个独立的操作更快（例如，如果您使用 create()），因为使用 bulkWrite() 只需与 MongoDB 进行一次往返。

Mongoose 将对您提供的操作执行转换。唯一的例外是 将 updateOne 或 updateMany 的 update 运算符设置为管道：Mongoose **不会** 转换更新管道。

此函数不会触发任何中间件，无论是save()还是update()。 如果您需要为每个文档触发save()中间件，请使用create()。

示例

Character.bulkWrite([
  {
    insertOne: {
      document: {
        name: 'Eddard Stark',
        title: 'Warden of the North'
      }
    }
  },
  {
    updateOne: {
      filter: { name: 'Eddard Stark' },
      // If you were using the MongoDB driver directly, you'd need to do
      // `update: { $set: { title: ... } }` but mongoose adds $set for
      // you.
      update: { title: 'Hand of the King' }
    }
  },
  {
    deleteOne: {
      filter: { name: 'Eddard Stark' }
    }
  }
]).then(res => {
 // Prints "1 1 1"
 console.log(res.insertedCount, res.modifiedCount, res.deletedCount);
});

// Mongoose does **not** cast update pipelines, so no casting for the `update` option below.
// Mongoose does still cast `filter`
await Character.bulkWrite([{
  updateOne: {
    filter: { name: 'Annika Hansen' },
    update: [{ $set: { name: 7 } }] // Array means update pipeline, so Mongoose skips casting
  }
}]);

支持的操作包括：

• insertOne
• updateOne
• updateMany
• deleteOne
• deleteMany
• replaceOne

将给定的 POJO 强制转换为模型的模式

示例

const Test = mongoose.model('Test', Schema({ num: Number }));

const obj = Test.castObject({ num: '42' });
obj.num; // 42 as a number

Test.castObject({ num: 'not a number' }); // Throws a ValidationError

删除此模型模式中未定义的所有索引。 由syncIndexes()使用。

返回的 Promise 解析为一个数组，其中包含已删除索引的名称列表。

计算数据库集合中与filter匹配的文档数量。

示例

Adventure.countDocuments({ type: 'jungle' }, function (err, count) {
  console.log('there are %d jungle adventures', count);
});

如果您想计算大型集合中的所有文档，请改用estimatedDocumentCount()函数。如果您调用countDocuments({})，MongoDB 将始终执行完整集合扫描，而不是使用任何索引。

countDocuments()函数类似于count()，但有一些countDocuments()不支持的操作符。以下是count()支持但countDocuments()不支持的操作符，以及建议的替代方案

• $where: $expr
• $near: $geoWithin 以及 $center
• $nearSphere: $geoWithin 以及 $centerSphere

保存一个或多个文档到数据库的快捷方式。 MyModel.create(docs) 对docs中的每个文档执行new MyModel(doc).save()。

此函数触发以下中间件。

• save()

示例

// Insert one new `Character` document
await Character.create({ name: 'Jean-Luc Picard' });

// Insert multiple new `Character` documents
await Character.create([{ name: 'Will Riker' }, { name: 'Geordi LaForge' }]);

// Create a new character within a transaction. Note that you **must**
// pass an array as the first parameter to `create()` if you want to
// specify options.
await Character.create([{ name: 'Jean-Luc Picard' }], { session });

创建此模型的集合。 默认情况下，如果未指定任何索引，Mongoose 不会创建模型的集合，直到创建任何文档。 使用此方法显式创建集合。

注意 1：您可能需要在启动事务之前调用此方法。 请参见https://www.mongodb.com/docs/manual/core/transactions/#transactions-and-operations

注意 2：如果您的模式包含索引或唯一字段，则不必调用此方法。 在这种情况下，只需使用Model.init()。

示例

const userSchema = new Schema({ name: String })
const User = mongoose.model('User', userSchema);

User.createCollection().then(function(collection) {
  console.log('Collection is created!');
});

类似于ensureIndexes()，只是它使用createIndex 函数。

创建Atlas 搜索索引。 此函数仅在连接到 MongoDB Atlas 时有效。

示例

const schema = new Schema({ name: { type: String, unique: true } });
const Customer = mongoose.model('Customer', schema);
await Customer.createSearchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });

模型使用的连接实例。

从集合中删除与conditions匹配的所有文档。 它返回一个对象，该对象包含属性deletedCount，其中包含已删除文档的数量。 行为类似于remove()，但会删除与conditions匹配的所有文档，无论single 选项如何。

示例

await Character.deleteMany({ name: /Stark/, age: { $gte: 18 } }); // returns {deletedCount: x} where x is the number of documents deleted.

注意

此函数触发deleteMany 查询钩子。 阅读中间件文档以了解详情。

从集合中删除与conditions匹配的第一个文档。 它返回一个对象，该对象包含属性deletedCount，表示已删除的文档数量。 行为类似于remove()，但最多删除一个文档，无论single 选项如何。

示例

await Character.deleteOne({ name: 'Eddard Stark' }); // returns {deletedCount: 1}

注意

此函数触发deleteOne 查询钩子。 阅读中间件文档以了解详情。

对Model.syncIndexes()执行一个干运行，返回syncIndexes()将在运行syncIndexes()时删除和创建的索引。

示例

const { toDrop, toCreate } = await Model.diffIndexes();
toDrop; // Array of strings containing names of indexes that `syncIndexes()` will drop
toCreate; // Array of strings containing names of indexes that `syncIndexes()` will create

添加鉴别器类型。

示例

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

  this.add({
    name: String,
    createdAt: Date
  });
}
util.inherits(BaseSchema, Schema);

const PersonSchema = new BaseSchema();
const BossSchema = new BaseSchema({ department: String });

const Person = mongoose.model('Person', PersonSchema);
const Boss = Person.discriminator('Boss', BossSchema);
new Boss().__t; // "Boss". `__t` is the default `discriminatorKey`

const employeeSchema = new Schema({ boss: ObjectId });
const Employee = Person.discriminator('Employee', employeeSchema, 'staff');
new Employee().__t; // "staff" because of 3rd argument above

为distinct 操作创建一个查询。

示例

const query = Link.distinct('url');
query.exec();

按名称删除现有的Atlas 搜索索引。 此函数仅在连接到 MongoDB Atlas 时有效。

示例

const schema = new Schema({ name: { type: String, unique: true } });
const Customer = mongoose.model('Customer', schema);
await Customer.dropSearchIndex('test');

为模式中声明的每个索引向 Mongo 发送createIndex 命令。 createIndex 命令按顺序发送。

示例

await Event.ensureIndexes();

完成后，将在此Model 上发出一个index 事件，如果发生错误，则传递一个错误。

示例

const eventSchema = new Schema({ thing: { type: 'string', unique: true } })
const Event = mongoose.model('Event', eventSchema);

Event.on('index', function (err) {
  if (err) console.error(err); // error occurred during index creation
});

注意：不建议您在生产环境中运行此操作。 索引创建可能会影响数据库性能，具体取决于您的负载。 谨慎使用。

估计 MongoDB 集合中的文档数量。 比使用countDocuments() 更快，因为estimatedDocumentCount() 使用的是集合元数据，而不是扫描整个集合。

示例

const numAdventures = await Adventure.estimatedDocumentCount();

事件发射器，报告发生的任何错误。 对全局错误处理很有用。

示例

MyModel.events.on('error', err => console.log(err.message));

// Prints a 'CastError' because of the above handler
await MyModel.findOne({ _id: 'Not a valid ObjectId' }).catch(noop);

仅当数据库中存在至少一个与给定的filter 匹配的文档时，才返回包含_id 的文档；否则返回null。

在幕后，MyModel.exists({ answer: 42 }) 等效于MyModel.findOne({ answer: 42 }).select({ _id: 1 }).lean()

示例

await Character.deleteMany({});
await Character.create({ name: 'Jean-Luc Picard' });

await Character.exists({ name: /picard/i }); // { _id: ... }
await Character.exists({ name: /riker/i }); // null

此函数触发以下中间件。

• findOne()

查找文档。

在发送命令之前，Mongoose 会将filter 强制转换为匹配模型模式。 有关 Mongoose 如何强制转换filter 的更多信息，请参见我们的查询强制转换教程。

示例

// find all documents
await MyModel.find({});

// find all documents named john and at least 18
await MyModel.find({ name: 'john', age: { $gte: 18 } }).exec();

// executes, name LIKE john and only selecting the "name" and "friends" fields
await MyModel.find({ name: /john/i }, 'name friends').exec();

// passing options
await MyModel.find({ name: /john/i }, null, { skip: 10 }).exec();

通过其 _id 字段查找单个文档。 findById(id) 几乎*等效于findOne({ _id: id })。 如果您想按文档的_id 查询，请使用findById() 而不是findOne()。

在发送命令之前，id 会根据模式进行强制转换。

此函数触发以下中间件。

• findOne()

* 除了它如何处理undefined。 如果您使用findOne()，您会发现findOne(undefined) 和findOne({ _id: undefined }) 等效于findOne({})，并返回任意文档。 但是，mongoose 会将findById(undefined) 转换为findOne({ _id: null })。

示例

// Find the adventure with the given `id`, or `null` if not found
await Adventure.findById(id).exec();

// select only the adventures name and length
await Adventure.findById(id, 'name length').exec();

通过文档的 _id 字段发出 MongoDB findOneAndDelete() 命令。 换句话说，findByIdAndDelete(id) 是findOneAndDelete({ _id: id }) 的简写。

此函数触发以下中间件。

• findOneAndDelete()

通过文档的 _id 字段发出 mongodb findOneAndUpdate 命令。findByIdAndUpdate(id, ...) 等效于 findOneAndUpdate({ _id: id }, ...)。

查找匹配的文档，根据 update 参数更新它，传递任何 options，并返回找到的文档（如果有）。

此函数触发以下中间件。

• findOneAndUpdate()

示例

A.findByIdAndUpdate(id, update, options)  // returns Query
A.findByIdAndUpdate(id, update)           // returns Query
A.findByIdAndUpdate()                     // returns Query

注意

所有不是 atomic 操作名称的顶层更新键都被视为设置操作

示例

Model.findByIdAndUpdate(id, { name: 'jason bourne' }, options)

// is sent as
Model.findByIdAndUpdate(id, { $set: { name: 'jason bourne' }}, options)

注意

findOneAndX 和 findByIdAndX 函数支持有限的验证。可以通过设置 runValidators 选项来启用验证。

如果需要完整的验证，请使用传统的先检索文档的方法。

const doc = await Model.findById(id)
doc.name = 'jason bourne';
await doc.save();

查找一个文档。

在发送命令之前，conditions 会被转换为其各自的 SchemaTypes。

注意： conditions 是可选的，如果 conditions 为 null 或 undefined，mongoose 将向 MongoDB 发送一个空的 findOne 命令，该命令将返回一个任意文档。如果按 _id 查询，请使用 findById() 代替。

示例

// Find one adventure whose `country` is 'Croatia', otherwise `null`
await Adventure.findOne({ country: 'Croatia' }).exec();

// Model.findOne() no longer accepts a callback

// Select only the adventures name and length
await Adventure.findOne({ country: 'Croatia' }, 'name length').exec();

发出 MongoDB findOneAndDelete() 命令。

查找匹配的文档，将其删除，并返回找到的文档（如果有）。

此函数触发以下中间件。

• findOneAndDelete()

示例

A.findOneAndDelete(conditions, options)  // return Query
A.findOneAndDelete(conditions) // returns Query
A.findOneAndDelete()           // returns Query

findOneAndX 和 findByIdAndX 函数支持有限的验证。可以通过设置 runValidators 选项来启用验证。

如果需要完整的验证，请使用传统的先检索文档的方法。

const doc = await Model.findById(id)
doc.name = 'jason bourne';
await doc.save();

发出 MongoDB findOneAndReplace() 命令。

查找匹配的文档，将其替换为提供的文档，并返回该文档。

此函数将触发以下查询中间件。

• findOneAndReplace()

示例

A.findOneAndReplace(filter, replacement, options)  // return Query
A.findOneAndReplace(filter, replacement) // returns Query
A.findOneAndReplace()                    // returns Query

发出 mongodb findOneAndUpdate 命令。

查找匹配的文档，根据 update 参数更新它，传递任何 options，并将找到的文档（如果有）返回给回调。如果传递了 callback，则查询会执行，否则会返回 Query 对象。

示例

A.findOneAndUpdate(conditions, update, options)  // returns Query
A.findOneAndUpdate(conditions, update)           // returns Query
A.findOneAndUpdate()                             // returns Query

注意

所有不是 atomic 操作名称的顶层更新键都被视为设置操作

示例

const query = { name: 'borne' };
Model.findOneAndUpdate(query, { name: 'jason bourne' }, options)

// is sent as
Model.findOneAndUpdate(query, { $set: { name: 'jason bourne' }}, options)

注意

findOneAndX 和 findByIdAndX 函数支持有限的验证，可以通过设置 runValidators 选项来启用验证。

如果需要完整的验证，请使用传统的先检索文档的方法。

const doc = await Model.findById(id);
doc.name = 'jason bourne';
await doc.save();

从现有的原始数据（已预先保存在数据库中）创建新文档的快捷方式。返回的文档最初没有标记为已修改的路径。

示例

// hydrate previous data into a Mongoose document
const mongooseCandy = Candy.hydrate({ _id: '54108337212ffb6d459f854c', type: 'jelly bean' });

此函数负责根据模式选项初始化 MongoDB 中的基础连接。此函数执行以下操作

• createCollection()，除非 autoCreate 选项被关闭
• ensureIndexes()，除非 autoIndex 选项被关闭
• 如果启用了 autoSearchIndex，则在所有模式搜索索引上执行 createSearchIndex()。

当使用 mongoose.model() 或 connection.model() 创建模型时，Mongoose 会自动调用此函数，因此无需调用 init() 来触发索引构建。

但是，如果需要获取索引完成后将解析的 Promise，则可能需要调用 init()。如果需要在继续操作之前等待索引构建，调用 await Model.init() 将很有帮助。例如，如果需要在继续执行测试用例之前等待唯一索引构建。

示例

const eventSchema = new Schema({ thing: { type: 'string', unique: true } })
// This calls `Event.init()` implicitly, so you don't need to call
// `Event.init()` on your own.
const Event = mongoose.model('Event', eventSchema);

await Event.init();
console.log('Indexes are done building!');

验证文档数组并将其插入 MongoDB（如果它们都有效）的快捷方式。此函数比 .create() 快，因为它只向服务器发送一个操作，而不是为每个文档发送一个操作。

Mongoose 始终在向 MongoDB 发送 insertMany 之前验证每个文档。因此，如果一个文档存在验证错误，则不会保存任何文档，除非您将 ordered 选项设置为 false。

此函数不会触发保存中间件。

此函数触发以下中间件。

• insertMany()

示例

const docs = await Movies.insertMany([
  { name: 'Star Wars' },
  { name: 'The Empire Strikes Back' }
]);
docs[0].name; // 'Star Wars'

// Return raw result from MongoDB
const result = await Movies.insertMany([
  { name: 'Star Wars' },
  { name: 'The Empire Strikes Back' }
], { rawResult: true });

console.log 的辅助函数。给定一个名为“MyModel”的模型，返回字符串 'Model { MyModel }'。

示例

const MyModel = mongoose.model('Test', Schema({ name: String }));
MyModel.inspect(); // 'Model { Test }'
console.log(MyModel); // Prints 'Model { Test }'

列出当前在 MongoDB 中定义的索引。这可能与您在模式中定义的索引相同，也可能不同，具体取决于您是否使用 autoIndex 选项 以及是否手动构建索引。

列出此模型集合上的所有 Atlas 搜索索引。此函数仅在连接到 MongoDB Atlas 时有效。

示例

const schema = new Schema({ name: { type: String, unique: true } });
const Customer = mongoose.model('Customer', schema);

await Customer.createSearchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });
const res = await Customer.listSearchIndexes(); // Includes `[{ name: 'test' }]`

填充文档引用。

在 Mongoose 6 中更改：您调用 populate() 的模型应该是“本地字段”模型，而不是“外键字段”模型。

可用的顶层选项

• path：要填充的空间分隔路径
• select：要选择的可选字段
• match：要匹配的可选查询条件
• model：用于填充的模型的可选名称
• options：可选的查询选项，如 sort、limit 等
• justOne：可选的布尔值，如果为 true，Mongoose 将始终将 path 设置为文档，如果未找到文档，则设置为 null。如果为 false，Mongoose 将始终将 path 设置为数组，如果未找到文档，则该数组将为空。默认情况下从模式推断。
• strictPopulate：可选的布尔值，设置为 false 以允许填充模式中不存在的路径。

示例

const Dog = mongoose.model('Dog', new Schema({ name: String, breed: String }));
const Person = mongoose.model('Person', new Schema({
  name: String,
  pet: { type: mongoose.ObjectId, ref: 'Dog' }
}));

const pets = await Pet.create([
  { name: 'Daisy', breed: 'Beagle' },
  { name: 'Einstein', breed: 'Catalan Sheepdog' }
]);

// populate many plain objects
const users = [
  { name: 'John Wick', dog: pets[0]._id },
  { name: 'Doc Brown', dog: pets[1]._id }
];
await User.populate(users, { path: 'dog', select: 'name' });
users[0].dog.name; // 'Daisy'
users[0].dog.breed; // undefined because of `select`

如果未指定 name，则返回用于创建此文档的模型实例。如果指定了 name，则返回具有给定 name 的模型。

示例

const doc = new Tank({});
doc.$model() === Tank; // true
await doc.$model('User').findById(id);

在调用 save() 且 isNew 为 false 时附加到查询的其他属性。

模型使用的基本 Mongoose 实例。

如果这是一个鉴别器模型，则 baseModelName 是基本模型的名称。

此模型使用的集合实例。Mongoose 集合是围绕 [MongoDB Node.js 驱动程序集合](MongoDB Node.js 驱动程序集合) 的一个薄包装器。使用 Model.collection 表示您绕过了 Mongoose 中间件、验证和强制转换。

此属性是只读的。修改此属性将不起作用。

模型使用的集合。

模型使用的连接。

从数据库中删除此文档。

示例

await product.deleteOne();
await Product.findById(product._id); // null

为该模型注册的鉴别器。

发出我们希望此文档版本增量的信号。

示例

const doc = await Model.findById(id);
doc.increment();
await doc.save();

如果未指定 name，则返回用于创建此文档的模型实例。如果指定了 name，则返回具有给定 name 的模型。

示例

const doc = new Tank({});
doc.$model() === Tank; // true
await doc.$model('User').findById(id);

模型的名称

如果 document.isNew 为 true，则通过将新文档插入数据库来保存此文档，或者如果 isNew 为 false，则发送仅包含修改过的路径的 updateOne 操作。

示例

product.sold = Date.now();
product = await product.save();

如果保存成功，返回的 Promise 将会使用保存的文档来实现。

示例

const newProduct = await product.save();
newProduct === product; // true

在编译此模型后应用对此模型模式所做的更改。默认情况下，在编译模型后将虚拟和其他属性添加到模式不会有任何效果。调用此函数以应用以后添加的虚拟和属性。

示例

const schema = new mongoose.Schema({ field: String });
const TestModel = mongoose.model('Test', schema);
TestModel.schema.virtual('myVirtual').get(function() {
  return this.field + ' from myVirtual';
});
const doc = new TestModel({ field: 'Hello' });
doc.myVirtual; // undefined

TestModel.recompileSchema();
doc.myVirtual; // 'Hello from myVirtual'

用给定的文档替换现有文档（没有像 $set 这样的原子运算符）。

示例

const res = await Person.replaceOne({ _id: 24601 }, { name: 'Jean Valjean' });
res.matchedCount; // Number of documents matched
res.modifiedCount; // Number of documents modified
res.acknowledged; // Boolean indicating the MongoDB server received the operation.
res.upsertedId; // null or an id containing a document that had to be upserted.
res.upsertedCount; // Number indicating how many documents had to be upserted. Will either be 0 or 1.

此函数触发以下中间件。

• replaceOne()

模型使用的模式。

需要 MongoDB >= 3.6.0. 为诸如因果一致性、可重试写入 和 事务 之类的优势启动 MongoDB 会话。

调用 MyModel.startSession() 等效于调用 MyModel.db.startSession()。

此函数不会触发任何中间件。

示例

const session = await Person.startSession();
let doc = await Person.findOne({ name: 'Ned Stark' }, null, { session });
await doc.remove();
// `doc` will always be null, even if reading from a replica set
// secondary. Without causal consistency, it is possible to
// get a doc back from the below query if the query reads from a
// secondary that is experiencing replication lag.
doc = await Person.findOne({ name: 'Ned Stark' }, null, { session, readPreference: 'secondary' });

使 MongoDB 中的索引与在此模型模式中定义的索引相匹配。此函数将删除模型模式中未定义的任何索引（_id 索引除外），并构建模式中存在但在 MongoDB 中不存在的任何索引。

请参阅 介绍性博客文章 以了解更多信息。

示例

const schema = new Schema({ name: { type: String, unique: true } });
const Customer = mongoose.model('Customer', schema);
await Customer.collection.createIndex({ age: 1 }); // Index is not in schema
// Will drop the 'age' index and create an index on `name`
await Customer.syncIndexes();

您应该谨慎地在负载较大的生产应用程序上运行 syncIndexes()，因为索引构建是昂贵的操作，意外的索引删除会导致性能下降。在运行 syncIndexes() 之前，您可以使用 diffIndexes() 函数 来检查 syncIndexes() 将删除和创建哪些索引。

示例

const { toDrop, toCreate } = await Model.diffIndexes();
toDrop; // Array of strings containing names of indexes that `syncIndexes()` will drop
toCreate; // Array of strings containing names of indexes that `syncIndexes()` will create

翻译任何别名字段/条件，以便最终的查询或文档对象是纯净的

示例

await Character.find(Character.translateAliases({
   '名': 'Eddard Stark' // Alias for 'name'
});

默认情况下，translateAliases() 会用别名字段覆盖原始字段。因此，如果 n 是 name 的别名，{ n: 'alias', name: 'raw' } 将解析为 { name: 'alias' }。但是，您可以设置 errorOnDuplicates 选项，如果存在可能冲突的路径，则抛出错误。查询的 translateAliases 选项使用 errorOnDuplicates。

注意

只翻译对象类型的参数，其他任何内容都将被原始返回

与 updateOne() 相同，但 MongoDB 会更新与 filter 匹配的所有文档（而不是仅第一个文档），而不管 multi 选项的值如何。

注意 updateMany 不会 触发更新中间件。请改用 pre('updateMany') 和 post('updateMany')。

const res = await Person.updateMany({ name: /Stark$/ }, { isDeleted: true });
res.matchedCount; // Number of documents matched
res.modifiedCount; // Number of documents modified
res.acknowledged; // Boolean indicating the MongoDB server received the operation. This may be false if Mongoose did not send an update to the server because the update was empty.
res.upsertedId; // null or an id containing a document that had to be upserted.
res.upsertedCount; // Number indicating how many documents had to be upserted. Will either be 0 or 1.

仅更新与 filter 匹配的第一个文档。

const res = await Person.updateOne({ name: 'Jean-Luc Picard' }, { ship: 'USS Enterprise' });
res.matchedCount; // Number of documents matched
res.modifiedCount; // Number of documents modified
res.acknowledged; // Boolean indicating the MongoDB server received the operation. This may be false if Mongoose did not send an update to the server because the update was empty.
res.upsertedId; // null or an id containing a document that had to be upserted.
res.upsertedCount; // Number indicating how many documents had to be upserted. Will either be 0 or 1.

更新现有的 Atlas 搜索索引。此函数仅在连接到 MongoDB Atlas 时有效。

const schema = new Schema({ name: { type: String, unique: true } });
const Customer = mongoose.model('Customer', schema);
await Customer.updateSearchIndex('test', { mappings: { dynamic: true } });

根据此模型的模式转换和验证给定的对象，并将给定的 context 传递给自定义验证器。

const Model = mongoose.model('Test', Schema({
  name: { type: String, required: true },
  age: { type: Number, required: true }
});

try {
  await Model.validate({ name: null }, ['name'])
} catch (err) {
  err instanceof mongoose.Error.ValidationError; // true
  Object.keys(err.errors); // ['name']
}

需要运行 MongoDB >= 3.6.0 的副本集。 使用 MongoDB 变更流 监控基础集合的更改。

const doc = await Person.create({ name: 'Ned Stark' });
const changeStream = Person.watch().on('change', change => console.log(change));
// Will print from the above `console.log()`:
// { _id: { _data: ... },
//   operationType: 'delete',
//   ns: { db: 'mydb', coll: 'Person' },
//   documentKey: { _id: 5a51b125c5500f5aa094c7bd } }
await doc.remove();

创建一个 Query，应用传入的条件，并返回 Query。

User.find({ age: { $gte: 21, $lte: 65 } });

User.where('age').gte(21).lte(65).exec();

User
.where('age').gte(21).lte(65)
.where('name', /^b/i)
... etc