クラス: Mongo::Collection

継承:

オブジェクト

オブジェクト
Mongo::Collection

すべて表示

次による拡張機能。: 転送可能

次のことが含まれます。: ヘルパー、 QueryableEncryption 、再試行可能な

定義:: lib/mongo/コレクション.rb

、lib/mongo/コレクション/view.rb、lib/mongo/コレクション/helpers.rb、lib/mongo/コレクション/view/iterable.rb、lib/mongo/コレクション/view/readable

rb、lib/mongo/コレクション/view/writable.rb、lib/mongo/コレクション/view/imutable.rb、lib/mongo/コレクション/view/map_reduce.rb、lib/mongo/コレクション/view/集計.rb、
lib/mongo/コレクション/view/explainable.rb、lib/mongo/コレクション/view/change_stream.rb、lib/mongo/コレクション/queryable_encryption.rb、lib/mongo/コレクション/view/Builder/map_reduce.rb、lib/

mongo/
コレクション/view/Builder/
集計.rb、lib/mongo/コレクション/view/ 集計/behavior.rb、lib/mongo/コレクション/view/change_stream/retryable.rb

Overview

データベース内のコレクションと、そのコレクションに直接適用できる操作を表します。

以来

2.0.0

名前空間で定義済み

Modules: ヘルパー、 QueryableEncryptionクラス:ビュー

定数の概要の削減

CAPED = Capped オプション。 以来 2.1.0

上限 付き.freeze

ns = ns フィールド定数。 以来 2.1.0

'ns'.freeze

CHANGEABLE_OPTIONS = 新しいコレクションインスタンスで#withメソッドを使用して更新できるオプション。 以来 2.1.0

[ :read, :read_concern, :write, :write_concern ].freeze

CREATE_COLLECTION_OPTIONS =

この定数は、プライベート API の一部です。 この定数は将来削除または変更される可能性があるため、可能な限り使用しないでください。

オプションは、コレクション作成オプションを変換するにマップします。

以来

2.0.0

{
  :time_series => :timeseries,
  :expire_ after => :expireAfterSeconds,
  :clustered_index => :clusteredIndex,
  :change_stream_pre_and_post_images => :changeStreamPreAndPostImages,
  :encrypted_fields => :encryptedFields,
  :validator => :validator,
  :view_on => :viewOn
}

QueryableEncryptionから含まれる定数

QueryableEncryption::QE 2 _MIN_WIRE_VERSION

インスタンス属性の概要を折りたたむ

#database ⇒ Mongo::Database readOnly

コレクションが存在するデータベース。
#name = string readOnly

コレクションの名前。
#options ⇒ Hash readOnly

コレクションオプション

インスタンスメソッドの概要を折りたたむ

# == (その他) ==(その他) ========= ================================================================== false

コレクションが別のオブジェクトと等しいかどうかを確認します。
#集計（パイプライン、オプション = {{}） → View::Aggregation

コレクションに対して集計を実行します。
# bulk_write （リクエスト、オプション = {}） = BulkWrite::Result

一括書き込み操作のバッチを実行します。
上限付きか。 = true | false

コレクションは上限付きか？
カウント（フィルター = nil、オプション = {}） = 整数非推奨
非推奨。
代わりに #count_documents またはestimate_document_count_count を使用してください。ただし、#count_documents に切り替えるときに次の演算子を置き換える必要があることに注意してください。
```
* $where should be replaced with $expr (only works on 3.6+)
* $near should be replaced with $geoWithin with $center
* $nearSphere should be replaced with $geoWithin with $centerSphere
```
count_documents （フィルター = {}、オプション = {}） = 整数

クエリに一致するドキュメントの数を取得します。
#create （opts = {{}） = 結果

データベースにコレクションを強制的に作成します。
# delete_many （フィルター = nil、オプション = {}） = 結果

コレクションからドキュメントを削除します。
# delete_one （フィルター = nil、オプション = {}） = 結果

コレクションからドキュメントを削除します。
個別の数（フィールド名、フィルター = nil、オプション = {{}） = 配列 <Object>

特定のフィールドの個別の値のリストを取得します。
#drop （ops = {}） = 結果

コレクションを削除します。
#estimate_document_count （オプション = {}） = 整数

コレクションのメタデータを使用して、コレクション内のドキュメント数の推定値を取得します。
# find （フィルター = nil、オプション = {}） = CollectionView

コレクション内のドキュメントを検索します。
# find_one_and_delete （フィルター、オプション = {}） = BSON::Document ^?

findAndModify 経由でデータベース内の単一のドキュメントを検索し、削除し、元のドキュメントを返します。
# find_one_and_replace （フィルター、置換、オプション = {}） = BSON::Document

1 つのドキュメントを検索して置き換え、特に指定されていない限り、元のドキュメントを返します。
#find_one_and_update(filter, update, options = {}) ⇒ BSON::Document

findAndModify 経由で単一のドキュメントを検索し、そのドキュメントを更新すると、特に指定されていない限り、元のドキュメントを返します。
#indexes(options = {}) ⇒ Index::View

このコレクションのすべてのインデックスのビューを取得します。
#初期化（データベース、名前、オプション = {}） = コレクション = コレクションコンストラクター

新しいコレクションをインスタンス化します。
# insert_many （ドキュメント、オプション = {}） = 結果

提供されたドキュメントをコレクションに挿入します。
# insert_one （ドキュメント、opts = {}) = 結果

コレクションに単一のドキュメントを挿入します。
詳しくは、を 検査しますstring

コレクションのpretty-printed string 検査を取得します。
#名前空間= string

コレクションの完全修飾名前空間を取得します。
# operation_timeouts（opts = {}） = ハッシュ private

操作レベルで設定されている Timeout_ms 値（存在する場合）、および/またはコレクション/データベース/クライアントレベルで設定されている timeout_ms 値（存在する場合）。
# parallel_scan （cursor_count、オプション = {}）= Array=========================================================<Cursor>

コレクションビューで並列スキャンを実行します。
#read_concern =ハッシュ

このコレクションインスタンスの有効な読み取り保証を取得します。
# read_preference =ハッシュ

このコレクションの有効な読み込み設定（read preference）を取得します。
# replace_one （フィルター, 置換, オプション = {}） = 結果

コレクション内の単一のドキュメントを新しいドキュメントに置き換えます。
Search_indexs（オプション = {}）= SearchIndex::View

このコレクションのすべての検索インデックスのビューを取得します。
# server_selector = Mongo::ServerSelector

このコレクションのサーバーセレクターを取得します。
システム_コレクション? = ブール値 private

コレクションがシステムコレクションであるかどうか。
#timeout_ms ⇒ Integer | nil private

このデータベースでは、または対応するクライアントではである操作タイムアウト。
#update_many(filter, update, options = {}) ⇒ Result

コレクション内のドキュメントを更新します。
#update_one(filter, update, options = {}) ⇒ Result

コレクション内の 1 つのドキュメントを更新します。
多数表示（パイプライン = []、オプション = {}） = ChangeStream

MongoDB サーバーのバージョン3.6以降、$changeStream" パイプラインステージは集計フレームワークでサポートされています。
(new_options)を使用した# Mongo::Collection

新しいコレクションインスタンス。
#write_concern = Mongo::WriteConcern

このコレクションの有効な書込み保証 (write concern) を取得します。
#write_concern_with_session （セッション）=Mongo::WriteConcern private

このコレクションに対する操作に使用する書込み保証 (write concern) を取得します（セッションが指定された場合）。

コンストラクターの詳細

#初期化（データベース、名前、オプション = {}） = コレクション =`コレクション`

新しいコレクションをインスタンス化します。

例:

新しいコレクションをインスタンス化します。

Mongo::Collection.new(database, 'test')

パラメーター:

database （ Mongo::Database ） —

コレクションのデータベース。
name ( string 、 Symbol ) —

コレクション名。
options （ハッシュ） （デフォルトは{}です） —

コレクションオプション
ops （ハッシュ） —

カスタマイズ可能なオプションのセット

オプションハッシュ（ options ）:

:read_concern （ハッシュ） —
読み取り保証 (read concern) オプションハッシュと、次の任意キーが含まれます。
- : レベル- シンボルとしての読み込み設定（read preference）レベル。有効な値
```
are *:local*, *:majority*, and *:snapshot*
```
:read （ハッシュ） —
読み込み設定（read preference）オプション。ハッシュには以下の項目が含まれる場合があります。
- : モード- シンボルとして指定された読み込み設定（read preference）。有効な値は、 :primary 、 :primary_preferred 、 :secondary 、 :secondary_preferred 、 :nearestです。
- : tags_sets - ハッシュの配列。
- : local_threshold 。
:session （セッション） —

操作に使用するセッション。
:size （整数） —

Capped コレクションのサイズ。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合、データベースまたはクライアントから値が継承されることを意味します。

次の値が発生します。

(Error::InvalidCollectionName)

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、162 行

デフォルト 初期化(database, name, options = {})
  発生 エラー::InvalidCollectionName.新着情報 ただし、 name
  場合 options[:write] & & options[:write_concern] & & options[:write] != options[:write_concern]
    発生 ArgumentError, " :write と :write_concern の両方が指定されている場合、それらは同一である必要があります。 #{ options . explain } "
  end
  @database = database
  @name = name.to_s.freeze
  @options = options.dup
  @timeout_ms = options.削除(:timeout_ms)
=開始 WriteConcern オブジェクト サポート
  の場合 @options[:write_concern].is_a?(WriteConcern::Base)
    # インスタンスをキャッシュして、不必要に再構築されないようにします。
    @write_concern = @options[:write_concern]
    @options[:write_concern] = @write_concern.options
  end
=end
  @options.freeze
end

インスタンス属性の詳細

#database ⇒ `Mongo::Database` (readonly)

コレクションが存在するデータベースを返します。

次の値を返します。

（ Mongo::Database ） —

コレクションが存在するデータベース。

以来

2.0.0



46
47
48

# ファイル 'lib/mongo/ コレクション' は、46 行

デフォルト database
  @database
end

# name = `string` （読み取り専用）

コレクションの名前を返します。

次の値を返します。

( string ) —

コレクションの名前。

以来

2.0.0



49
50
51

# ファイル 'lib/mongo/ コレクション' は、49 行

デフォルト name
  @name
end

オプション=`ハッシュ`（読み取り専用）

コレクションオプションを返します。

次の値を返します。

（ハッシュ） —

コレクションオプション

以来

2.0.0



52
53
54

# ファイル 'lib/mongo/ コレクション' は、52 行

デフォルト options
  @options
end

インスタンスメソッドの詳細

# == (その他) ==(その他) ========= `================================================================== false`

コレクションが別のオブジェクトと等しいかどうかを確認します。名前とデータベースが等価であるかどうかを確認します。

例:

コレクションの等価性を確認します。

collection == other

パラメーター:

その他（オブジェクト） —

チェックするオブジェクト。

次の値を返します。

（ true | false ） —

オブジェクトが等しい場合。

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、89 行

デフォルト ==(その他)
  return false ただし、 その他.is_a?(コレクション)
  name == その他.name & & database == その他.database & & options == その他.options
end

#集計（パイプライン、オプション = {{}） → `View::Aggregation`

コレクションに対して集計を実行します。

例:

集計を実行します。

collection.aggregate([ { "$group" => { "_id" => "$city", "tpop" => { "$sum" => "$pop" }}} ])

パラメーター:

パイプライン（ <Hash>配列） —

集計パイプライン。
options （ハッシュ） （デフォルトは{}です） —

集計オプション。

オプションハッシュ（ options ）:

:allow_disk_use （ true | false ） —

集計中にディスクの使用が許可されている場合は、を true に設定します。
:batch_size （整数） —

バッチするごとに返すドキュメントの数。
:bypass_document_validation （ true | false ） —

ドキュメントレベルの検証をスキップするかどうか。
:collation （ハッシュ） —

使用する照合。
:comment （オブジェクト） —

このコマンドに添付するユーザー指定のコメント。
:hint （ string ） —

集計に使用するインデックス。
:let （ハッシュ） —

パイプラインで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。
:max_time_ms （整数） —

クエリの実行を許可する最大時間（ミリ秒単位）。このオプションは非推奨です。代わりに :timeout_ms を使用してください。
:session （セッション） —

使用するセッション。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。

次の値を返します。

（ビュー::集計） —

集計オブジェクト。

以来

2.1.0



568
569
570

# ファイル 'lib/mongo/ コレクション' は、568 行

デフォルト 集計(パイプライン, options = {})
  ビュー.新着情報(自己, {}, options).集計(パイプライン, options)
end

# bulk_write （リクエスト、オプション = {}） = `BulkWrite::Result`

一括書き込み操作のバッチを実行します。

例:

一括書き込みを実行します。

collection.bulk_write(operations, options)

パラメーター:

リクエスト (Enumerable<Hash>) —

一括書き込みリクエスト。
options （ハッシュ） （デフォルトは{}です） —

オプション。

オプションハッシュ（ options ）:

: ordered （ true | false ） —

操作を順番に実行するかどうか。
:write_concern （ハッシュ） —

書込み保証（write concern）オプション。 :w => 整数、 :fsync => ブール値、 :j => ブール値になります。
:bypass_document_validation （ true | false ） —

ドキュメントレベルの検証をスキップするかどうか。
:session （セッション） —

一連の操作に使用するセッション。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。

次の値を返します。

（ BulkWrite::Result ） —

操作の結果。

以来

2.0.0



942
943
944

# ファイル 'lib/mongo/ コレクション' は、942 行

デフォルト bulk_write(リクエスト, options = {})
  一括書込み (write).新着情報(自己, リクエスト, options).実行する
end

上限付きか。 = `true | false`

コレクションは上限付きか？

例:

コレクションは上限付きか？

collection.capped?

次の値を返します。

（ true | false ） —

コレクションが上限付きの場合。

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、321 行

デフォルト 上限付きか
  database.list_collections(フィルター: { name: name })
    .最初に
    &.dig('options', CAPED) || false
end

カウント（フィルター = nil、オプション = {}） =`整数`

非推奨。

代わりに #count_documents またはestimate_document_count_count を使用してください。ただし、#count_documents に切り替えるときに次の演算子を置き換える必要があることに注意してください。

* $where should be replaced with $expr (only works on 3.6+)
* $near should be replaced with $geoWithin with $center
* $nearSphere should be replaced with $geoWithin with $centerSphere

コレクション内の一致するドキュメントの推定数を取得します。

例:

カウントを取得します。

collection.count(name: 1)

パラメーター:

フィルター（ハッシュ） （デフォルトはnil ） —

一致するドキュメントのフィルター。
options （ハッシュ） （デフォルトは{}です） —

カウントオプション。

オプションハッシュ（ options ）:

:hint （ハッシュ） —

使用するインデックス。
:limit （整数） —

カウントするドキュメントの最大数。
:max_time_ms （整数） —

クエリの実行を許可する最大時間（ミリ秒単位）。このオプションは非推奨です。代わりに :timeout_ms を使用してください。
:skip （整数） —

カウントする前にスキップするドキュメントの数。
:read （ハッシュ） —

読み込み設定（read preference）オプション。
:collation （ハッシュ） —

使用する照合。
:session （セッション） —

使用するセッション。
:comment （オブジェクト） —

このコマンドに添付するユーザー指定のコメント。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。

次の値を返します。

(整数) —

ドキュメント数。

以来

2.1.0



685
686
687

# ファイル 'lib/mongo/ コレクション' は、685 行

デフォルト count(フィルター = nil, options = {})
  ビュー.新着情報(自己, フィルター || {}, options).count(options)
end

count_documents （フィルター = {}、オプション = {}） =`整数`

クエリに一致するドキュメントの数を取得します。非推奨のカウントメソッドとは異なり、推定値ではなく、フィルターに一致するドキュメントの正確な数（またはフィルターが提供されていない場合は、コレクション内のドキュメントの正確な数）が返されます。

#estimated_document_count を使用して、コレクションのメタデータを使用して、コレクション内のドキュメント数の推定値を取得します。

パラメーター:

フィルター（ハッシュ） （デフォルトは{}です） —

一致するドキュメントのフィルター。
options （ハッシュ） （デフォルトは{}です） —

操作のオプション。

オプションハッシュ（ options ）:

:skip （整数） —

スキップするドキュメントの数。
:hint （ハッシュ） —

デフォルトのインデックス選択を上書きし、MongoDB がクエリに特定のインデックスを使用するように強制します。サーバーバージョン3.6 + が必要です。
:limit （整数） —

カウントするDocsの最大数。
:max_time_ms （整数） —

コマンドの実行を許可する最大時間。
:read （ハッシュ） —

読み込み設定（read preference）オプション。
:collation （ハッシュ） —

使用する照合。
:session （セッション） —

使用するセッション。
:comment （オブジェクト） —

このコマンドに添付するユーザー指定のコメント。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。

次の値を返します。

(整数) —

ドキュメント数。

以来

2.6.0



719
720
721

# ファイル 'lib/mongo/ コレクション' は、719 行

デフォルト count_documents(フィルター = {}, options = {})
  ビュー.新着情報(自己, フィルター, options).count_documents(options)
end

#create （opts = {{}） =`結果`

データベースにコレクションを強制的に作成します。

例:

コレクションを作成するよう強制します。

collection.create

パラメーター:

ops （ハッシュ） （デフォルトは{}です） —

作成操作のオプション。

オプションハッシュ（ opts ）:

:Capped （ true | false ） —

固定サイズのコレクションを作成します。
:change_stream_pre_and_post_images （ハッシュ） —
作成されたコレクションで変更前と変更後のイメージを有効にするために使用されます。ハッシュには以下の項目が含まれる場合があります。
- :enabled - true または false。
:clustered_index （ハッシュ） —
クラスター化インデックスの作成。このオプションは、このコレクションが _id でクラスター化される方法を指定します。ハッシュには以下の項目が含まれる場合があります。
- :key - クラスター化されたインデックスキーフィールド。 { _id: 1 } に設定する必要があります。
- : 一意- true に設定する必要があります。コレクションは、クラスター化されたインデックスキー値がインデックス内の既存の値と一致する挿入または更新されたドキュメントを受け入れません。
- :name - 任意。クラスター化されたインデックスを一意に識別する名前。
:collation （ハッシュ） —

コレクションの作成時に使用する照合です。このオプションは、コレクションメソッドを呼び出すときにサーバーに送信されません。
:encrypted_fields （ハッシュ） —

Queryable Encryption のために暗号化されたフィールドを説明するハッシュ。
:expire_ after （整数） —

古い時系列データを削除する秒数を示す数値。
:max （整数） —

Capped コレクション内の最大ドキュメント数。サイズ制限は最大よりも優先されます。
: パイプライン（ Array <Hash> ） —

パイプラインステージの配列。このパイプラインを view_on コレクションまたはビューに適用するとビューが作成されます。
:session （セッション） —

操作に使用するセッション。
:size （整数） —

Capped コレクションのサイズ。
:time_series （ハッシュ） —
時系列コレクションを作成します。ハッシュには以下の項目が含まれる場合があります。
- :timeField - 各時系列ドキュメントの日付を含むフィールドの名前。
- :metaField - 各時系列ドキュメントのメタデータを含むフィールドの名前。
- :granularity - 粒度を、連続する受信測定値間の時間範囲に最も近い値に設定します。指定できる値は、秒（デフォルト）、分（分）、時間（時間）です。
:validator （ハッシュ） —

コレクションのドキュメント検証オプションをハッシュする説明。
:view_on （ string ） —

ビューの作成元となるコレクションまたはビューの名前。
:write （ハッシュ） —

非推奨。 :write_concern オプションと同等。
:write_concern （ハッシュ） —

書込み保証（write concern）オプション。 :w => Integer|String、 :fsync => ブール値、 :j => ブール値にすることができます。

次の値を返します。

（結果） —

コマンドの結果です。

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、382 行

デフォルト create(ops = {})
  # 読み取りオプションを渡してコマンドを作成すると、コマンドが中断されます。
  # 読み取りオプションをフィルタリングで除外します。 セッションもここでは除外されます
  は with_session の呼び出しで使用され、次の一部ではない必要があります
  # 操作。 操作に渡されると、BSON は失敗します
  # シリアル化。
  TODO は、次の場合に読み取りオプションのリストをクラスレベルの定数に配置します
  # では、それらの完全なセットが何であるかがわかります。
  options = ハッシュ[自己.options.merge(ops).拒否 行う |キー, 価値|
    %w(読み取り read_preference read_concern セッション).include?(キー.to_s)
  end]
  Ruby オプションをサーバー スタイルに変換する。
  CREATE_COLLECTION_OPTIONS.各 行う |Ruby_key, server_key|
    場合 options.key?(Ruby_key)
      options[server_key] = options.削除(Ruby_key)
    end
  end
  操作 = { :create => name }.merge(options)
  操作.削除(:write)
  操作.削除(:write_concern)
  クライアント.送信(:with_session, ops) 行う |セッション|
    write_concern = 場合 ops[:write_concern]
      WriteConcern.得る(ops[:write_concern])
    else
      自己.write_concern
    end

    context = 操作::Context.新着情報(
      クライアント: クライアント,
      セッション: セッション
    )
    Max_create_qe_collections(ops[:encrypted_fields], クライアント, セッション) 行う |encryption_fields|
      操作::作成.新着情報(
        セレクター: 操作,
        db_name: database.name,
        write_concern: write_concern,
        セッション: セッション,
        # これらはコレクション オプションであり、照合は次ではないことに注意してください:
        create メソッドに渡されるオプションから取得された#。
        collation: options[:collation] || options[「照合」],
        encryption_fields: encryption_fields,
        validator: options[:validator],
      ).実行する(
        next_primary(nil, セッション),
        context: context
      )
    end
  end
end

# delete_many （フィルター = nil、オプション = {}） =`結果`

コレクションからドキュメントを削除します。

例:

コレクションから複数のドキュメントを削除します。

collection.delete_many

パラメーター:

フィルター（ハッシュ） （デフォルトはnil ） —

使用するフィルター。
options （ハッシュ） （デフォルトは{}です） —

オプション。

オプションハッシュ（ options ）:

:collation （ハッシュ） —

使用する照合。
:session （セッション） —

使用するセッション。
:hint （ハッシュ | string ） —

この操作に使用するインデックス。ハッシュ（例: { _id : 1 } またはstring （例: ID ）。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。

次の値を返します。

（結果） —

データベースからの応答。

以来

2.1.0



994
995
996

# ファイル 'lib/mongo/ コレクション' は、994 行

デフォルト delete_many(フィルター = nil, options = {})
  find(フィルター, options).delete_many(options)
end

# delete_one （フィルター = nil、オプション = {}） =`結果`

コレクションからドキュメントを削除します。

例:

コレクションから単一のドキュメントを削除します。

collection.delete_one

パラメーター:

フィルター（ハッシュ） （デフォルトはnil ） —

使用するフィルター。
options （ハッシュ） （デフォルトは{}です） —

オプション。

オプションハッシュ（ options ）:

:collation （ハッシュ） —

使用する照合。
:session （セッション） —

使用するセッション。
:hint （ハッシュ | string ） —

この操作に使用するインデックス。ハッシュ（例: { _id : 1 } またはstring （例: ID ）。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。

次の値を返します。

（結果） —

データベースからの応答。

以来

2.1.0



968
969
970

# ファイル 'lib/mongo/ コレクション' は、968 行

デフォルト delete_one(フィルター = nil, options = {})
  find(フィルター, options).delete_one(options)
end

個別の数（フィールド名、フィルター = nil、オプション = {{}） =`配列 <Object>`

特定のフィールドの個別の値のリストを取得します。

例:

個別の値を取得します。

collection.distinct('name')

パラメーター:

field_name （シンボル、 string ） —

フィールドの名前。
フィルター（ハッシュ） （デフォルトはnil ） —

個別の値を取得するドキュメント。
options （ハッシュ） （デフォルトは{}です） —

個別のコマンドオプション。

オプションハッシュ（ options ）:

:max_time_ms （整数） —

クエリの実行を許可する最大時間（ミリ秒単位）。このオプションは非推奨です。代わりに :timeout_ms を使用してください。
:read （ハッシュ） —

読み込み設定（read preference）オプション。
:collation （ハッシュ） —

使用する照合。
:session （セッション） —

使用するセッション。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。

次の値を返します。

（配列<Object> ） —

個別の値のリスト。

以来

2.1.0



771
772
773

# ファイル 'lib/mongo/ コレクション' は、771 行

デフォルト distinct(field_name, フィルター = nil, options = {})
  ビュー.新着情報(自己, フィルター || {}, options).distinct(field_name, options)
end

#drop （ops = {}） =`結果`

注：

コレクションが存在しない場合に返されるエラーは非表示になります。

コレクションを削除します。また、コレクションに関連付けられているすべてのインデックスと、関連付けられているQueryable Encryptionコレクションも削除されます。

例:

コレクションを削除します。

collection.drop

パラメーター:

ops （ハッシュ） （デフォルトは{}です） —

削除操作のオプション。
options （ハッシュ） —

カスタマイズ可能なオプションのセット

オプションハッシュ（ opts ）:

:session （セッション） —

操作に使用するセッション。
:write_concern （ハッシュ） —

書込み保証（write concern）オプション。
:encrypted_fields （ハッシュ | nil ） —

'create' コレクションヘルパーに提供された暗号化されたフィールドハッシュ。

次の値を返します。

（結果） —

コマンドの結果です。

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、454 行

デフォルト drop(ops = {})
  クライアント.with_session(ops) 行う |セッション|
    Max_drop_em_collections(ops[:encrypted_fields], クライアント, セッション) 行う
      temp_write_concern = write_concern
      write_concern = 場合 ops[:write_concern]
        WriteConcern.得る(ops[:write_concern])
      else
        temp_write_concern
      end
      context = 操作::Context.新着情報(
        クライアント: クライアント,
        セッション: セッション,
        operation_timeouts: operation_timeouts(ops)
      )
      操作 = 操作::drop.新着情報({
        セレクター: { :drop => name },
        db_name: database.name,
        write_concern: write_concern,
        セッション: セッション,
      })
      do_drop(操作, セッション, context)
    end
  end
end

#estimate_document_count （オプション = {}） =`整数`

コレクションのメタデータを使用して、コレクション内のドキュメント数の推定値を取得します。

コレクション内のドキュメントの正確な数を取得するには、#count_documents を使用するか、フィルターに一致するドキュメントをカウントするには、 #count_documents

パラメーター:

options （ハッシュ） （デフォルトは{}です） —

操作のオプション。

オプションハッシュ（ options ）:

:max_time_ms （整数） —

サーバー上でコマンドの実行を許可する最大時間。
:read （ハッシュ） —

読み込み設定（read preference）オプション。
:comment （オブジェクト） —

このコマンドに添付するユーザー指定のコメント。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。

次の値を返します。

(整数) —

ドキュメント数。

以来

2.6.0



744
745
746

# ファイル 'lib/mongo/ コレクション' は、744 行

デフォルト Estimated_document_count(options = {})
  ビュー.新着情報(自己, {}, options).Estimated_document_count(options)
end

# find （フィルター = nil、オプション = {}） = `CollectionView`

コレクション内のドキュメントを検索します。

例:

セレクターでコレクション内のドキュメントを検索します。

collection.find(name: 1)

コレクション内のすべてのドキュメントを取得します。

collection.find

パラメーター:

フィルター（ハッシュ） （デフォルトはnil ） —

find で使用するフィルター。
options （ハッシュ） （デフォルトは{}です） —

find のオプション。

オプションハッシュ（ options ）:

:allow_disk_use （ true | false ） —

true に設定されている場合、サーバーは検索操作の実行中に一時データをディスクに書込むことができます。このオプションは、MongoDB サーバーバージョン 4.4 以降でのみ使用できます。
:allow_ partial_results （ true | false ） —

一部のシャードがダウンした場合にクエリで部分的な結果を得ることができます。
:batch_size （整数） —

MongoDB からの結果の各バッチで返されたドキュメントの数。
:collation （ハッシュ） —

使用する照合。
:comment （オブジェクト） —

このコマンドに添付するユーザー指定のコメント。
: cursor_type （ :tailable 、 :tailable_await ） —

使用するカーソルの型。
:limit （整数） —

クエリから返されるDocsの最大数。
:max_time_ms （整数） —

クエリの実行を許可する最大時間（ミリ秒単位）。このオプションは非推奨です。代わりに :timeout_ms を使用してください。
:modifiers （ハッシュ） —

クエリの出力または動作を変更するメタ演算子を含むドキュメント。
:no_cursor_timeout （ true | false ） —

サーバーは通常、非アクティブな期間（ 10分）の後にアイドルカーソルをタイムアウトして、過剰なメモリの使用を防ぎます。それを防ぐには、このオプションをに設定します。
:oplog_replace （ true | false ） —

内部レプリケーションのみを使用する場合、アプリケーションはこのオプションを設定しないでください。
:プロジェクション（ハッシュ） —

結果セット内の各ドキュメントに含める、または除外するフィールド。
:session （セッション） —

使用するセッション。
:skip （整数） —

結果を返す前にスキップするDocsの数。
:sort （ハッシュ） —

結果セットがソートされるキーと方向のペア。
:timeout_mode （ :cursor_Lifetime | :iteration ） —

:timeout_ms の解釈方法（カーソルの有効期間、または反復ごとに適用されるかどうか）。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。

次の値を返します。

(CollectionView) —

コレクションビュー。

以来

2.0.0



532
533
534

# ファイル 'lib/mongo/ コレクション' は、532 行

デフォルト find(フィルター = nil, options = {})
  ビュー.新着情報(自己, フィルター || {}, options)
end

# find_one_and_delete （フィルター、オプション = {}） = `BSON::Document` ^?

findAndModify 経由でデータベース内の単一のドキュメントを検索し、削除し、元のドキュメントを返します。

例:

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

collection.find_one_and_delete(name: 'test')

パラメーター:

フィルター（ハッシュ） —

使用するフィルター。
options （ハッシュ） （デフォルトは{}です） —

オプション。

オプションハッシュ（ options ）:

:max_time_ms （整数） —

クエリの実行を許可する最大時間（ミリ秒単位）。このオプションは非推奨です。代わりに :timeout_ms を使用してください。
:プロジェクション（ハッシュ） —

返されるドキュメントに含める、または除外するフィールド。
:sort （ハッシュ） —

結果セットがソートされるキーと方向のペア。
:write_concern （ハッシュ） —

書込み保証（write concern）オプション。コレクションの書込み保証 (write concern) のデフォルトです。
:collation （ハッシュ） —

使用する照合。
:session （セッション） —

使用するセッション。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:hint （ハッシュ | string ） —

この操作に使用するインデックス。ハッシュ（例: { _id : 1 } またはstring （例: ID ）。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。

次の値を返します。

(BSON::Document, nil) —

ドキュメント（見つかった場合）。

以来

2.1.0



1157
1158
1159

# ファイル 'lib/mongo/ コレクション' は、1157 行

デフォルト find_one_and_delete(フィルター, options = {})
  find(フィルター, options).find_one_and_delete(options)
end

# find_one_and_replace （フィルター、置換、オプション = {}） = `BSON::Document`

1 つのドキュメントを検索して置き換え、特に指定されていない限り、元のドキュメントを返します。

例:

ドキュメントを検索して置き換え、元のドキュメントを返します。

collection.find_one_and_replace({ name: 'test' }, { name: 'test1' })

ドキュメントを検索して置き換え、新しいドキュメントを返します。

collection.find_one_and_replace({ name: 'test' }, { name: 'test1' }, :return_document => :after)

パラメーター:

フィルター（ハッシュ） —

使用するフィルター。
replacement （ BSON::Document ） —

置換ドキュメントです。
options （ハッシュ） （デフォルトは{}です） —

オプション。

オプションハッシュ（ options ）:

:max_time_ms （整数） —

コマンドの実行を許可する最大時間（ミリ秒単位）。
:プロジェクション（ハッシュ） —

返されるドキュメントに含める、または除外するフィールド。
:sort （ハッシュ） —

結果セットがソートされるキーと方向のペア。
:return_document （記号） —

: 前または : 後。
:upsert （ true | false ） —

ドキュメントが存在しない場合にアップサートを実行するかどうか。
:bypass_document_validation （ true | false ） —

ドキュメントレベルの検証をスキップするかどうか。
:write_concern （ハッシュ） —

書込み保証（write concern）オプション。コレクションの書込み保証 (write concern) のデフォルトです。
:collation （ハッシュ） —

使用する照合。
:session （セッション） —

使用するセッション。
:hint （ハッシュ | string ） —

この操作に使用するインデックス。ハッシュ（例: { _id : 1 } またはstring （例: ID ）。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。

次の値を返します。

（ BSON::Document ） —

ドキュメント。

以来

2.1.0



1243
1244
1245

# ファイル 'lib/mongo/ コレクション' は、1243 行

デフォルト find_one_and_replace(フィルター, replacement, options = {})
  find(フィルター, options).find_one_and_update(replacement, options)
end

#find_one_and_update(filter, update, options = {}) ⇒ `BSON::Document`

findAndModify 経由で単一のドキュメントを検索し、そのドキュメントを更新すると、特に指定されていない限り、元のドキュメントを返します。

例:

ドキュメントを検索して更新し、元のドキュメントを返します。

collection.find_one_and_update({ name: 'test' }, { "$set" => { name: 'test1' }})

ドキュメントを検索して更新し、更新されたドキュメントを返します。

collection.find_one_and_update({ name: 'test' }, { "$set" => { name: 'test1' }}, :return_document => :after)

パラメーター:

フィルター（ハッシュ） —

使用するフィルター。
update （ハッシュ | 配列 <Hash> ） —

更新ドキュメントまたはパイプライン。
options （ハッシュ） （デフォルトは{}です） —

オプション。

オプションハッシュ（ options ）:

:max_time_ms （整数） —

コマンドの実行を許可する最大時間（ミリ秒単位）。
:プロジェクション（ハッシュ） —

返されるドキュメントに含める、または除外するフィールド。
:sort （ハッシュ） —

結果セットがソートされるキーと方向のペア。
:return_document （記号） —

: 前または : 後。
:upsert （ true | false ） —

ドキュメントが存在しない場合にアップサートを実行するかどうか。
:bypass_document_validation （ true | false ） —

ドキュメントレベルの検証をスキップするかどうか。
:write_concern （ハッシュ） —

書込み保証（write concern）オプション。コレクションの書込み保証 (write concern) のデフォルトです。
:collation （ハッシュ） —

使用する照合。
:array_filters （配列） —

アップデートを適用する配列要素を指定するフィルターのセット。
:session （セッション） —

使用するセッション。
:hint （ハッシュ | string ） —

この操作に使用するインデックス。ハッシュ（例: { _id : 1 } またはstring （例: ID ）。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。

次の値を返します。

（ BSON::Document ） —

ドキュメント。

以来

2.1.0



1201
1202
1203

# ファイル 'lib/mongo/ コレクション' は、1201 行

デフォルト find_one_and_update(フィルター, update, options = {})
  find(フィルター, options).find_one_and_update(update, options)
end

#indexes(options = {}) ⇒ `Index::View`

このコレクションのすべてのインデックスのビューを取得します。反復処理できる、またはより多くの操作があります。

例:

インデックスビューを取得します。

collection.indexes

パラメーター:

options （ハッシュ） （デフォルトは{}です） —

すべてのインデックスのリストを取得するためのオプション。

オプションハッシュ（ options ）:

:session （セッション） —

使用するセッション。

次の値を返します。

（ インデックス ::View ） —

インデックスビュー。

以来

2.0.0



788
789
790

# ファイル 'lib/mongo/ コレクション' は、788 行

デフォルト indexes(options = {})
  Index::ビュー.新着情報(自己, options)
end

# insert_many （ドキュメント、オプション = {}） =`結果`

提供されたドキュメントをコレクションに挿入します。

例:

コレクションにドキュメントを挿入します。

collection.insert_many([{ name: 'test' }])

パラメーター:

ドキュメント (Enumerable<Hash>) —

挿入するドキュメント。
options （ハッシュ） （デフォルトは{}です） —

挿入オプション。

オプションハッシュ（ options ）:

:bypass_document_validation （ true | false ） —

ドキュメントレベルの検証をスキップするかどうか。
:comment （オブジェクト） —

このコマンドに添付するユーザー指定のコメント。
: ordered （ true | false ） —

操作を順番に実行するかどうか。
:session （セッション） —

操作に使用するセッション。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:write_concern （ハッシュ） —

書込み保証（write concern）オプション。 :w => 整数、 :fsync => ブール値、 :j => ブール値になります。

次の値を返します。

（結果） —

データベース応答ラッパー。

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、910 行

デフォルト insert_many(ドキュメント, options = {})
  クエリ キャッシュ.clear_namespace(namespace)

  inserts = ドキュメント.map{ |doc| { :insert_one => doc }}
  bulk_write(inserts, options)
end

# insert_one （ドキュメント、opts = {}) =`結果`

コレクションに単一のドキュメントを挿入します。

例:

コレクションにドキュメントを挿入します。

collection.insert_one({ name: 'test' })

パラメーター:

ドキュメント（ハッシュ） —

挿入するドキュメント。
ops （ハッシュ） （デフォルトは{}です） —

挿入オプション。
options （ハッシュ） —

カスタマイズ可能なオプションのセット

オプションハッシュ（ opts ）:

:bypass_document_validation （ true | false ） —

ドキュメントレベルの検証をスキップするかどうか。
:comment （オブジェクト） —

このコマンドに添付するユーザー指定のコメント。
:session （セッション） —

操作に使用するセッション。
:write_concern （ハッシュ） —

書込み保証（write concern）オプション。 :w => 整数、 :fsync => ブール値、 :j => ブール値になります。

次の値を返します。

（結果） —

データベース応答ラッパー。

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、849 行

デフォルト insert_one(ドキュメント, ops = {})
  クエリ キャッシュ.clear_namespace(namespace)

  クライアント.with_session(ops) 行う |セッション|
    write_concern = 場合 ops[:write_concern]
      WriteConcern.得る(ops[:write_concern])
    else
      write_concern_with_session(セッション)
    end

    場合 ドキュメント.nil?
      発生 ArgumentError, "挿入するドキュメントは nil にできません"
    end

    context = 操作::Context.新着情報(
      クライアント: クライアント,
      セッション: セッション,
      operation_timeouts: operation_timeouts(ops)
      )
    write_with_retry(write_concern, context: context) 行う |接続, txn_num, context|
      操作::Insert.新着情報(
        :documents => [ ドキュメント ],
        :db_name => database.name,
        :coll_name => name,
        :write_concern => write_concern,
        :bypass_document_validation => !!ops[:bypass_document_validation],
        :options => ops,
        :id_genator => クライアント.options[:id_genator],
        :session => セッション,
        :txn_num => txn_num,
        :comment => ops[:comment]
      ).execution_with_ connection(接続, context: context)
    end
  end
end

詳しくは、を検査し`string` ます

コレクションのpretty-printed string 検査を取得します。

例:

コレクションを調べます。

collection.inspect

次の値を返します。

( string ) —

コレクション検査。

以来

2.0.0



822
823
824

# ファイル 'lib/mongo/ コレクション' は、822 行

デフォルト 検査する
  " #< Mongo::Collection: 0 x #{ object_id } namespace= #{ namespace } > "
end

#名前空間= `string`

コレクションの完全修飾名前空間を取得します。

例:

完全修飾された名前空間を取得します。

collection.namespace

次の値を返します。

( string ) —

コレクションの名前空間。

以来

2.0.0



1255
1256
1257

# ファイル 'lib/mongo/ コレクション' は、1255 行

デフォルト namespace
  " #{データベース.名前} . #{名前} "
end

# operation_timeouts（opts = {}） = `ハッシュ`

このメソッドは、プライベート API の一部です。 このメソッドは将来削除または変更される可能性があるため、可能な限り使用しないでください。

操作レベルで設定されている timeout_ms 値（存在する場合）、および/またはコレクション/データベース/クライアントレベルで設定されている timeout_ms 値（存在する場合）を返します。

次の値を返します。

（ハッシュ） —

操作レベルで設定されている timeout_ms 値（存在する場合）、および/またはコレクション/データベース/クライアントレベルで設定されている timeout_ms 値（存在する場合）。

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、1280 行

デフォルト operation_timeouts(ops = {})
  TODO: 2 つのタイムアウトが個別に必要な場合は、再評価する必要があります。
  {}.タップ 行う |結果|
    場合 ops[:timeout_ms].nil?
      結果[:in inherited_timeout_ms] = timeout_ms
    else
      結果[: operation_timeout_ms] = ops.削除(:timeout_ms)
    end
  end
end

# parallel_scan （cursor_count、オプション = {{}）= `Array` ========================================================

コレクションビューで並列スキャンを実行します。

同時に反復処理できる最大 cursor_count カーソルのリストを返します。スキャン中にコレクションが変更されていない限り、各ドキュメントはカーソルの結果セットのいずれかに 1 回表示されます。

例:

コレクションスキャンを並行して実行します。

collection.parallel_scan(2)

パラメーター:

cursor_count (整数) —

返されるカーソルの最大数。
options （ハッシュ） （デフォルトは{}です） —

並列スキャンコマンドオプション。

オプションハッシュ（ options ）:

:max_time_ms （整数） —

クエリの実行を許可する最大時間（ミリ秒単位）。このオプションは非推奨です。代わりに :timeout_ms を使用してください。
:session （セッション） —

使用するセッション。
:timeout_mode （ :cursor_Lifetime | :iteration ） —

:timeout_ms の解釈方法（カーソルの有効期間、または反復ごとに適用されるかどうか）。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。

次の値を返します。

（配列 <カーソル> ） —

カーソルの配列。

以来



1025
1026
1027

# ファイル 'lib/mongo/ コレクション' は、1025 行

デフォルト parallel_scan(cursor_count, options = {})
  find({}, options).parallel_scan(cursor_count, options)
end

#read_concern =`ハッシュ`

このコレクションインスタンスの有効な読み取り保証を取得します。

コレクションオプションで読み取り保証 (read concern) が指定されている場合は、その読み取り保証 (read concern) が返されます。それ以外の場合は、データベースの有効な読み取り保証 (read concern) が返されます。

例:

読み取り保証 (read concern) を取得します。

collection.read_concern

次の値を返します。

（ハッシュ） —

読み取り保証 (read concern) 。

以来

2.2.0



193
194
195

# ファイル 'lib/mongo/ コレクション' は、193 行

デフォルト read_concern
  options[:read_concern] || database.read_concern
end

# read_preference =`ハッシュ`

このコレクションの有効な読み込み設定（read preference）を取得します。

コレクションオプションで読み込み設定（read preference）が指定されている場合は、その読み込み設定（read preference）が返されます。それ以外の場合は、データベースの有効な読み込み設定（read preference）が返されます。

例:

読み込み設定 (read preference) を取得します。

collection.read_preference

次の値を返します。

（ハッシュ） —

読み込み設定 (read preference)。

以来

2.0.0



221
222
223

# ファイル 'lib/mongo/ コレクション' は、221 行

デフォルト read_preference
  @read_preference ||= options[:read] || database.read_preference
end

# replace_one （フィルター, 置換, オプション = {}） =`結果`

コレクション内の単一のドキュメントを新しいドキュメントに置き換えます。

例:

単一のドキュメントを置き換えます。

collection.replace_one({ name: 'test' }, { name: 'test1' })

パラメーター:

フィルター（ハッシュ） —

使用するフィルター。
replacement （ハッシュ） —

置換ドキュメントです。
options （ハッシュ） （デフォルトは{}です） —

オプション。

オプションハッシュ（ options ）:

:upsert （ true | false ） —

ドキュメントが存在しない場合にアップサートを実行するかどうか。
:bypass_document_validation （ true | false ） —

ドキュメントレベルの検証をスキップするかどうか。
:collation （ハッシュ） —

使用する照合。
:session （セッション） —

使用するセッション。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:hint （ハッシュ | string ） —

この操作に使用するインデックス。ハッシュ（例: { _id : 1 } またはstring （例: ID ）。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。

次の値を返します。

（結果） —

データベースからの応答。

以来

2.1.0



1056
1057
1058

# ファイル 'lib/mongo/ コレクション' は、1056 行

デフォルト replace_one(フィルター, replacement, options = {})
  find(フィルター, options).replace_one(replacement, options)
end

Search_indexs（オプション = {}）= `SearchIndex::View`

注：

ID または名前のいずれか 1 つのみを指定できます。両方を指定するとエラーが発生しますが、両方を安全に省略できます。

このコレクションのすべての検索インデックスのビューを取得します。で反復処理または直接操作できます。 ID または名前が指定されている場合、イテレータは指定されたインデックスのみを返します。他のすべての操作では、id と名前は無視されます。

パラメーター:

options （ハッシュ） （デフォルトは{}です） —

ビューを設定するために使用するオプション。

オプションハッシュ（ options ）:

:id （ string ） —

クエリする特定のインデックスの ID（任意）
:name （ string ） —

クエリする特定のインデックスの名前（任意）
:aggregate （ハッシュ） —

集計コマンドに渡すハッシュするオプション（任意）

次の値を返します。

（ SearchIndex::View ） —

検索インデックスビュー。

以来

2.0.0



810
811
812

# ファイル 'lib/mongo/ コレクション' は、810 行

デフォルト search_indexes(options = {})
  SearchIndex::ビュー.新着情報(自己, options)
end

# server_selector = `Mongo::ServerSelector`

このコレクションのサーバーセレクターを取得します。

例:

サーバーセレクターを取得します。

collection.server_selector

次の値を返します。

（ Mongo::ServerSelector ） —

サーバーセレクター。

以来

2.0.0



205
206
207

# ファイル 'lib/mongo/ コレクション' は、205 行

デフォルト server_selector
  @server_selector ||= ServerSelector.得る(read_preference || database.server_selector)
end

システム_コレクション? =`ブール値`

コレクションがシステムコレクションであるかどうか。

次の値を返します。

（ブール値） —

システムがシステムコレクションであるかどうか。

以来

2.0.0



1264
1265
1266

# ファイル 'lib/mongo/ コレクション' は、1264 行

デフォルト system_collection?
  name.start_with?('システムです。 ')
end

#timeout_ms ⇒ `Integer | nil`

このデータベースまたは対応するクライアントの操作タイムアウトを返します。

次の値を返します。

(Integer | nil) —

このデータベースでは、または対応するクライアントではである操作タイムアウト。

以来

2.0.0



1272
1273
1274

# ファイル 'lib/mongo/ コレクション' は、1272 行

デフォルト timeout_ms
  @timeout_ms || database.timeout_ms
end

#update_many(filter, update, options = {}) ⇒ `Result`

コレクション内のドキュメントを更新します。

例:

コレクション内の複数のドキュメントを更新します。

collection.update_many({ name: 'test'}, '$set' => { name: 'test1' })

パラメーター:

フィルター（ハッシュ） —

使用するフィルター。
update （ハッシュ | 配列 <Hash> ） —

更新ドキュメントまたはパイプライン。
options （ハッシュ） （デフォルトは{}です） —

オプション。

オプションハッシュ（ options ）:

:upsert （ true | false ） —

ドキュメントが存在しない場合にアップサートを実行するかどうか。
:bypass_document_validation （ true | false ） —

ドキュメントレベルの検証をスキップするかどうか。
:collation （ハッシュ） —

使用する照合。
:array_filters （配列） —

アップデートを適用する配列要素を指定するフィルターのセット。
:session （セッション） —

使用するセッション。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:hint （ハッシュ | string ） —

この操作に使用するインデックス。ハッシュ（例: { _id : 1 } またはstring （例: ID ）。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。

次の値を返します。

（結果） —

データベースからの応答。

以来

2.1.0



1089
1090
1091

# ファイル 'lib/mongo/ コレクション' は、1089 行

デフォルト update_many(フィルター, update, options = {})
  find(フィルター, options).update_many(update, options)
end

#update_one(filter, update, options = {}) ⇒ `Result`

コレクション内の 1 つのドキュメントを更新します。

例:

コレクション内の 1 つのドキュメントを更新します。

collection.update_one({ name: 'test'}, '$set' => { name: 'test1'})

パラメーター:

フィルター（ハッシュ） —

使用するフィルター。
update （ハッシュ | 配列 <Hash> ） —

更新ドキュメントまたはパイプライン。
options （ハッシュ） （デフォルトは{}です） —

オプション。

オプションハッシュ（ options ）:

:upsert （ true | false ） —

ドキュメントが存在しない場合にアップサートを実行するかどうか。
:bypass_document_validation （ true | false ） —

ドキュメントレベルの検証をスキップするかどうか。
:collation （ハッシュ） —

使用する照合。
:array_filters （配列） —

アップデートを適用する配列要素を指定するフィルターのセット。
:session （セッション） —

使用するセッション。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。
:hint （ハッシュ | string ） —

この操作に使用するインデックス。ハッシュ（例: { _id : 1 } またはstring （例: ID ）。
:let （ハッシュ） —

コマンドで使用する変数のマッピング。詳細については、サーバーのドキュメントを参照してください。

次の値を返します。

（結果） —

データベースからの応答。

以来

2.1.0



1122
1123
1124

# ファイル 'lib/mongo/ コレクション' は、1122 行

デフォルト update_one(フィルター, update, options = {})
  find(フィルター, options).update_one(update, options)
end

`多数表示` （パイプライン = []、オプション = {}） = ChangeStream

注：

変更ストリームでは「majority」の読み取り保証のみが許可されます。

注：

このヘルパーメソッドは、再開可能性をサポートするために、 $changeStream ステージで未加工の集計を実行するよりも推奨されます。

MongoDB サーバーのバージョン3.6以降、$changeStream" パイプラインステージは集計フレームワークでサポートされています。このステージでは、ユーザーは特定のコレクションに対するすべての変更に対して通知を送信するようリクエストできます。

例:

指定されたコレクションの変更通知を取得します。

collection.watch([{ '$match' => { operationType: { '$in' => ['insert', 'replace'] } } }])

パラメーター:

パイプライン（ Array <Hash> ） （デフォルトは[] ） —

任意の追加のフィルター演算子。
options （ハッシュ） （デフォルトは{}です） —

変更ストリームオプション。

オプションハッシュ（ options ）:

: full_document （ string ） —

許可された値: nil、"default"、"updateLookup"、"whenAvalable"、"Required"

デフォルトでは値は送信されません（ nil）は、「デフォルト」と同等です。デフォルトでは、部分的な更新の変更通知には、ドキュメントに対する変更を説明するデルタが含まれます。

「updateLookup」に設定されている場合、部分的な更新の変更通知には、ドキュメントに対する変更を説明するデルタと、変更が発生した後一定時間後に変更されたドキュメント全体のコピーの両方が含まれます。

「whenAvalable」に設定すると、このイベントの変更後のイメージが利用可能な場合、置換および更新される変更イベントのために変更されたドキュメントの変更後のイメージを返すように変更ストリームを構成します。

「必須」に設定すると、「whenAvalable」と同じ動作をしますが、変更後のイメージが利用できない場合はエラーが発生します。
: full_document_Before_change （ string ） —

許可された値は: nil、"whenAvalable"、"Required"、"OFF" の場合、

デフォルトでは値は送信されません（ nil）は、「オフ」と同じです。

「 whenAvalable 」に設定すると、は、使用可能な場合、変更イベントの置換、アップデート、削除のために変更されたドキュメントの変更前のイメージを返すように変更ストリームを構成します。

「必須」に設定すると、「whenAvalable」と同じ動作をしますが、変更前のイメージが利用できない場合はエラーが発生します。
:resume_ after （ BSON::Document 、ハッシュ） —

新しい変更ストリームの論理的な開始点を指定します。
:max_await_time_ms （整数） —

新しいドキュメントが変更ストリームクエリを満たすまでにサーバーが待機する最大時間。
:batch_size （整数） —

バッチするごとに返すドキュメントの数。
:collation （ BSON::Document 、ハッシュ） —

使用する照合。
:session （セッション） —

使用するセッション。
:start_at_operation_time （ BSON::Timestamp ） —

指定されたタイムスタンプの時点またはその後に発生した変更のみを返します。サーバーに対して実行されたコマンドは、ここで使用できるクラスター時間を返します。サーバーバージョン4.0 + によってのみ認識されます。
:comment （オブジェクト） —

このコマンドに添付するユーザー指定のコメント。
:show_expanded_events （ブール値） —

サーバーが変更ストリームイベントの「展開」リストを送信できるようにします。このフラグセットに含まれる追加のイベントのリストは、createIndexes、dropIndexes、変更、作成、shardCollection、reshardCollection、 refineCollectionShardKey です。
:timeout_mode （ :cursor_Lifetime | :iteration ） —

:timeout_ms の解釈方法（カーソルの有効期間、または反復ごとに適用されるかどうか）。
:timeout_ms （整数） —

操作のタイムアウト（ミリ秒単位）。負でない整数である必要があります。 0 の明示的な値は無限を意味します。デフォルト値が設定されていない場合は、コレクション、データベース、またはクライアントから値が継承されることを意味します。

次の値を返します。

（ ChangeStream ） —

変更ストリームオブジェクト。

以来

2.5.0

# ファイル 'lib/mongo/ コレクション' は、646 行

デフォルト 監視(パイプライン = [], options = {})
  view_options = options.dup
  view_options[: cursor_type] = :tailable_await 場合 options[:max_await_time_ms]
  ビュー::ChangeStream.新着情報(ビュー.新着情報(自己, {}, view_options), パイプライン, nil, options)
end

(new_options)を使用した# `Mongo::Collection`

新しいコレクションインスタンスを返します。

例:

変更された読み取り保証を持つコレクションを取得します。

collection.with(read_concern: { level: :majority })

変更された書込み保証 (write concern) を持つコレクションを取得します。

collection.with(write_concern: { w:  3 })

パラメーター:

new_options （ハッシュ） —

使用する新しいオプション。

オプションハッシュ（ new_options ）:

:read （ハッシュ） —
読み込み設定（read preference）オプション。ハッシュには以下の項目が含まれる場合があります。
- : モード- シンボルとして指定された読み込み設定（read preference）。有効な値は、 :primary 、 :primary_preferred 、 :secondary 、 :secondary_preferred 、 :nearestです。
- : tags_sets - ハッシュの配列。
- : local_threshold 。
:read_concern （ハッシュ） —
読み取り保証 (read concern) オプションハッシュと、次の任意キーが含まれます。
- : レベル- シンボルとしての読み込み設定（read preference）レベル。有効な値
```
are *:local*, *:majority*, and *:snapshot*
```
:write （ハッシュ） —

非推奨。 :write_concern オプションと同等。
:write_concern （ハッシュ） —

書込み保証（write concern）オプション。 :w => Integer|String、 :fsync => ブール値、 :j => ブール値にすることができます。

次の値を返します。

（ Mongo::Collection ） —

新しいコレクションインスタンス。

以来

2.1.0

# ファイル 'lib/mongo/ コレクション' は、299 行

デフォルト と共に(new_options)
  new_options.キー.各 行う |k|
    発生 エラー::UnchangeableCollectionOption.新着情報(k) ただし、 CHANGEABLE_OPTIONS.include?(k)
  end
  options = @options.dup
  場合 options[:write] & & new_options[:write_concern]
    options.削除(:write)
  end
  場合 options[:write_concern] & & new_options[:write]
    options.削除(:write_concern)
  end
  コレクション.新着情報(database, name, options.update(new_options))
end

#write_concern = `Mongo::WriteConcern`

このコレクションの有効な書込み保証 (write concern) を取得します。

コレクションオプションで書込み保証 (write concern) が指定されている場合は、その書込み保証 (write concern) が返されます。それ以外の場合は、データベースの有効な書込み保証 (write concern) が返されます。

例:

書込み保証 (write concern) を取得します。

collection.write_concern

次の値を返します。

（ Mongo::WriteConcern ） —

書込み保証 (write concern) 。

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、237 行

デフォルト write_concern
  @write_concern ||= WriteConcern.得る(
    options[:write_concern] || options[:write] || database.write_concern)
end

#write_concern_with_session （セッション）= `Mongo::WriteConcern`

このコレクションに対する操作に使用する書込み保証 (write concern) を取得します（セッションが指定された場合）。

セッションがトランザクション内にあり、コレクションに未確認の書込み保証 (write concern) がある場合は、書込み保証 (write concern) の :w オプションを削除します。それ以外の場合は、変更されていない書込み保証を返します。

次の値を返します。

（ Mongo::WriteConcern ） —

書込み保証 (write concern) 。

以来

2.0.0

# ファイル 'lib/mongo/ コレクション' は、253 行

デフォルト write_concern_with_session(セッション)
  wc = write_concern
  場合 セッション & & セッション.in_transaction?
    場合 wc & & !wc.確認済み?
      ops = wc.options.dup
      ops.削除(:w)
      return WriteConcern.得る(ops)
    end
  end
  wc
end

クラス: Mongo::Collection

Overview

名前空間で定義済み

定数の概要の削減

QueryableEncryptionから含まれる定数

インスタンス属性の概要を折りたたむ

インスタンス メソッドの概要を折りたたむ

ヘルパーに含まれるメソッド

QueryableEncryptionに含まれるメソッド

再試行可能な に含まれるメソッド

コンストラクターの詳細

#初期化（データベース、名前、オプション = {}） = コレクション =コレクション

例:

新しい コレクションをインスタンス化します。

インスタンス属性の詳細

#database ⇒ Mongo::Database (readonly)

# name = string （読み取り専用）

オプション=ハッシュ（読み取り専用）

インスタンス メソッドの詳細

# == (その他) ==(その他) ========= ================================================================== false

例:

コレクションの等価性を確認します。

#集計（パイプライン、オプション = {{}） → View::Aggregation

例:

集計を実行します。

# bulk_write （リクエスト、オプション = {}） = BulkWrite::Result

例:

一括書き込みを実行します。

上限付きか。 = true | false

例:

コレクションは上限付きか？

カウント（フィルター = nil、オプション = {}） =整数

例:

カウントを取得します。

count_documents （フィルター = {}、オプション = {}） =整数

#create （opts = {{}） =結果

例:

コレクションを作成するよう強制します。

# delete_many （フィルター = nil、オプション = {}） =結果

例:

コレクションから複数のドキュメントを削除します。

# delete_one （フィルター = nil、オプション = {}） =結果

例:

コレクションから単一のドキュメントを削除します。

個別の数（フィールド名、フィルター = nil、オプション = {{}） =配列 <Object>

例:

個別の値を取得します。

#drop （ops = {}） =結果

例:

コレクションを削除します。

#estimate_document_count （オプション = {}） =整数

# find （フィルター = nil、オプション = {}） = CollectionView

例:

セレクターでコレクション内のドキュメントを検索します。

コレクション内のすべてのドキュメントを取得します。

# find_one_and_delete （フィルター、オプション = {}） = BSON::Document ?

例:

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

# find_one_and_replace （フィルター、置換、オプション = {}） = BSON::Document

例:

ドキュメントを検索して置き換え、元のドキュメントを返します。

ドキュメントを検索して置き換え、新しいドキュメントを返します。

#find_one_and_update(filter, update, options = {}) ⇒ BSON::Document

例:

ドキュメントを検索して更新し、元のドキュメントを返します。

ドキュメントを検索して更新し、更新されたドキュメントを返します。

#indexes(options = {}) ⇒ Index::View

例:

インデックス ビューを取得します。

# insert_many （ドキュメント、オプション = {}） =結果

例:

コレクションにドキュメントを挿入します。

# insert_one （ドキュメント、opts = {}) =結果

例:

コレクションにドキュメントを挿入します。

詳しくは、 を 検査しstring ます

例:

コレクションを調べます。

#名前空間= string

例:

インスタンスメソッドの概要を折りたたむ

再試行可能なに含まれるメソッド

#初期化（データベース、名前、オプション = {}） = コレクション =`コレクション`

新しいコレクションをインスタンス化します。

#database ⇒ `Mongo::Database` (readonly)

# name = `string` （読み取り専用）

オプション=`ハッシュ`（読み取り専用）

インスタンスメソッドの詳細

# == (その他) ==(その他) ========= `================================================================== false`

#集計（パイプライン、オプション = {{}） → `View::Aggregation`

# bulk_write （リクエスト、オプション = {}） = `BulkWrite::Result`

上限付きか。 = `true | false`

カウント（フィルター = nil、オプション = {}） =`整数`

count_documents （フィルター = {}、オプション = {}） =`整数`

#create （opts = {{}） =`結果`

# delete_many （フィルター = nil、オプション = {}） =`結果`

# delete_one （フィルター = nil、オプション = {}） =`結果`

個別の数（フィールド名、フィルター = nil、オプション = {{}） =`配列 <Object>`

#drop （ops = {}） =`結果`

#estimate_document_count （オプション = {}） =`整数`

# find （フィルター = nil、オプション = {}） = `CollectionView`

# find_one_and_delete （フィルター、オプション = {}） = `BSON::Document` ^?

# find_one_and_replace （フィルター、置換、オプション = {}） = `BSON::Document`

#find_one_and_update(filter, update, options = {}) ⇒ `BSON::Document`

#indexes(options = {}) ⇒ `Index::View`

インデックスビューを取得します。

# insert_many （ドキュメント、オプション = {}） =`結果`

# insert_one （ドキュメント、opts = {}) =`結果`

詳しくは、を検査し`string` ます

#名前空間= `string`

# operation_timeouts（opts = {}） = `ハッシュ`

# parallel_scan （cursor_count、オプション = {{}）= `Array` ========================================================

#read_concern =`ハッシュ`

# read_preference =`ハッシュ`

# replace_one （フィルター, 置換, オプション = {}） =`結果`

Search_indexs（オプション = {}）= `SearchIndex::View`

# server_selector = `Mongo::ServerSelector`

サーバーセレクターを取得します。

システム_コレクション? =`ブール値`

#timeout_ms ⇒ `Integer | nil`

#update_many(filter, update, options = {}) ⇒ `Result`

#update_one(filter, update, options = {}) ⇒ `Result`

`多数表示` （パイプライン = []、オプション = {}） = ChangeStream

(new_options)を使用した# `Mongo::Collection`

変更された読み取り保証を持つコレクションを取得します。

#write_concern = `Mongo::WriteConcern`

#write_concern_with_session （セッション）= `Mongo::WriteConcern`