モデル

モデルは、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 }) を介して行うか、Mongoose のショートカットメソッドである $where を Query チェーンまたは Mongoose モデルから使用できます。

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 プラグインを使用して、集計パイプラインの最小限のキャスティングを有効にできます。
• 返されるドキュメントは、Mongoose のドキュメントではなく、プレーンな JavaScript オブジェクトです (任意の形状のドキュメントが返される可能性があるため)。

集計の詳細

• 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() は、次の条件でエラーをスローします。

• 提供されたドキュメントの 1 つがバリデーションに失敗した場合。この場合、bulkSave() は bulkWrite() を送信せず、最初のバリデーションエラーをスローします。
• bulkWrite() が失敗した場合 (たとえば、MongoDB に接続できないか、重複キーエラーが原因)。
• bulkWrite() がいずれのドキュメントも挿入または更新しなかった場合。この場合、bulkSave() は DocumentNotFound エラーをスローします。

一部の save() 呼び出しのみが成功した場合、bulkSave() はエラーをスローしないことに注意してください。

複数の insertOne、updateOne、updateMany、replaceOne、deleteOne、および/または deleteMany 操作を 1 つのコマンドで MongoDB サーバーに送信します。これは、bulkWrite() では MongoDB へのラウンドトリップが 1 回しかないため、複数の独立した操作 (たとえば、create() を使用する場合) を送信するよりも高速です。

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 with $center
• $nearSphere: $geoWithin with $centerSphere

1 つ以上のドキュメントをデータベースに保存するためのショートカット。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: スキーマに index または unique フィールドが含まれている場合は、これを呼び出す必要はありません。その場合は、Model.init() を使用してください。

例

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

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

createIndex 関数を使用する点を除いて、ensureIndexes() と似ています。

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() と同様に動作しますが、single オプションに関係なく、conditions に一致するすべてのドキュメントを削除します。

例

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

注意

この関数は deleteMany クエリフックをトリガーします。詳細については、ミドルウェアドキュメントを参照してください。

コレクションから conditions に一致する最初のドキュメントを削除します。削除されたドキュメント数を示すプロパティ deletedCount を持つオブジェクトを返します。remove() と同様に動作しますが、single オプションに関係なく、最大で 1 つのドキュメントを削除します。

例

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 コレクション内のドキュメントの数を推定します。 estimatedDocumentCount() はコレクション全体をスキャンするのではなくコレクションメタデータを使用するため、大規模なコレクションでは countDocuments() を使用するよりも高速です。

例

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 に一致するドキュメントがデータベースに少なくとも 1 つ存在する場合は _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 でクエリする場合は、findOne() の代わりに findById() を使用してください。

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();

1つのドキュメントを検索します。

conditionsは、コマンドが送信される前にそれぞれのSchemaTypesにキャストされます。

注：conditionsはオプションであり、conditionsがnullまたはundefinedの場合、mongooseは空のfindOneコマンドをMongoDBに送信し、これは任意のドキュメントを返します。_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();

DBに事前に保存されている既存の生データから新しいドキュメントを作成するためのショートカット。返されたドキュメントには、最初に変更されたとマークされたパスはありません。

例

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

この関数は、スキーマオプションに基づいてMongoDBの基盤となる接続を初期化する役割を担っています。この関数は、次の操作を実行します。

• autoCreateオプションがオフにされていない限り、createCollection()を実行します。
• autoIndexオプションがオフにされていない限り、ensureIndexes()を実行します。
• autoSearchIndexが有効になっている場合、すべてのスキーマ検索インデックスでcreateSearchIndex()を実行します。

Mongooseは、mongoose.model()またはconnection.model()を使用してモデルが作成されると、この関数を自動的に呼び出すため、インデックスの構築をトリガーするために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に挿入するためのショートカット。この関数は、ドキュメントごとに1つではなく、1つの操作のみをサーバーに送信するため、.create()よりも高速です。

Mongooseは、MongoDBにinsertManyを送信する前に、常に各ドキュメントを検証します。したがって、1つのドキュメントに検証エラーがある場合、orderedオプションをfalseに設定しない限り、ドキュメントは保存されません。

この関数は、saveミドルウェアをトリガーしません。

この関数は、以下のミドルウェアをトリガーします。

• 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 ミドルウェア、検証、およびキャスティングをバイパスすることになります。

このプロパティは読み取り専用です。このプロパティを変更しても効果はありません。

モデルが使用するコレクション。

モデルが使用する接続。

このドキュメントを DB から削除します。

例

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.

この関数は、以下のミドルウェアをトリガーします。

• updateMany()

filter に一致する最初のドキュメントのみを更新します。

• $set のようなアトミック演算子を使用するのではなく、ドキュメント全体を上書きする場合は、replaceOne() を使用します。

例

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.

この関数は、以下のミドルウェアをトリガーします。

• updateOne()

既存の 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 変更ストリームを使用して、基になるコレクションの変更を監視します。

この関数は、ミドルウェアをトリガーしません。特に、集計ミドルウェアをトリガーしません。

ChangeStream オブジェクトは、次のイベントを発生させるイベントエミッターです。

• 'change': 変更が発生しました。以下の例を参照してください
• 'error': 回復不能なエラーが発生しました。特に、変更ストリームは現在、レプリカセットプライマリへの接続が失われた場合にエラーになります。更新については、この GitHub issue を参照してください。
• 'end': 基になるストリームが閉じられた場合に発生します
• 'close': 基になるストリームが閉じられた場合に発生します

例

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();

クエリを作成し、渡された条件を適用して、クエリを返します。

たとえば、次のように記述する代わりに

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

代わりに次のように記述できます

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

Query クラスも where をサポートしているため、チェーンを続けることができます

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