类：Mongo::Collection

继承：

对象

对象
Mongo::Collection

显示全部

扩展方式：: 可转发

包括：: 助手、 QueryableEncryption 、 Retryable

定义于：: lib/ Mongo/ 集合.rb 、
lib/

Mongo/
集合/view.rb、
lib/ Mongo/ 集合/helpers.rb、
lib/
Mongo/ 集合/view/iterable.rb、 lib/ Mongo/ 集合/view/可读。 rb, lib/ Mongo/ 集合/view/writable.rb, lib/
Mongo/ 集合/view/immutable.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/ 聚合、lib/ Mongo/
集合/view/ 聚合/behavior.rb、lib/
Mongo/ 集合/view/change_stream/retryable.rb

Overview

表示数据库中的集合以及可直接应用于集合的操作。

由于：

2.0.0

在命名空间下定义

模块： 助手、 QueryableEncryption类：视图

常量摘要折叠

CAPPED = 固定大小选项。 由于： 2.1.0

' capped '.冻结

NS = ns字段常量。 由于： 2.1.0

' ns '.冻结

CHANGEABLE_OPTIONS = 可以通过 #with 方法在新的 Collection实例上更新的选项。 由于： 2.1.0

[ :read, :read_concern, :write, :write_concern ].冻结

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

实例属性摘要折叠

#数据库⇒ Mongo::Database 只读

集合所在的数据库。
#名称⇒ string 只读

集合的名称。
# options ⇒ 哈希只读

集合选项。

实例方法摘要折叠

# == (other) ⇒ true | false

检查集合是否等于另一个对象。
#aggregate (管道, options = {}) ⇒ View::Aggregation

对集合执行聚合。
# bulk_write (requests, options = {}) ⇒ BulkWrite::Result

执行批处理批量写入操作。
#固定大小？ ⇒ true | false

集合是否有上限？
# count (filter = nil, options = {}) ⇒ Integer 已弃用
已弃用。
请改用#count_documents 或estimated_document_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 (filter = {}, options = {}) ⇒ Integer

获取与查询匹配的文档数。
# create (opts = {}) ⇒ 结果

强制在数据库中创建集合。
# delete_many (过滤 = nil, options = {}) ⇒ 结果

从集合中删除文档。
# delete_one (过滤 = nil, options = {}) ⇒ 结果

从集合中删除文档。
# distinct (field_name, 过滤 = nil, options = {}) ⇒ Array<Object>

获取特定字段的非重复值列表。
# drop (opts = {}) ⇒ 结果

删除该集合。
#estimated_document_count (options = {}) ⇒ Integer

使用集合元数据获取集合中文档的估计数量。
# find (filter = nil, options = {}) ⇒ CollectionView

在集合中查找文档。
# find_one_and_delete (过滤, options = {}) =" BSON::Document ^?

通过 findAndModify 在数据库中查找单个文档并将其删除，同时返回原始文档。
# find_one_and_replace (过滤, replacement, options = {}) ⇒ BSON::Document

查找并替换单个文档，并返回原始文档，除非另有说明。
#find_one_and_update(filter, update, options = {}) ⇒ BSON::Document

通过 findAndModify 查找单个文档并进行更新，除非另有指定，否则返回原始文档。
#indexes(options = {}) ⇒ Index::View

获取此集合的所有索引的视图。
#initialize (数据库, name, options = {}) ⇒ 集合构造函数

实例化一个新集合。
# insert_many (documents, options = {}) ⇒ 结果

将提供的文档插入到集合中。
# insert_one (文档, opts = {}) ⇒ 结果

将单个文档插入到集合中。
#检查⇒ string

为集合进行美观打印的string检查。
#命名空间⇒ string

获取集合的完全限定命名空间。
# operation_timeups (opts = {}) ⇒ 哈希 private

在操作级别上设立的timeout_ms 值（如果有），和/或在集合/数据库/客户端级别上设立的timeout_ms（如果有）。
#parallel_scan (cursor_count, options = {}) ⇒ Array<Cursor>

对集合视图执行并行扫描。
# read_concern ⇒ 哈希

获取此集合实例的有效读关注。
# read_preference ⇒ 哈希

获取此集合的有效读取偏好（read preference）。
# replace_one (过滤, replacement, options = {}) ⇒ 结果

用新文档替换集合中的单个文档。
# search_indexes (options = {}) ⇒ SearchIndex::View

获取此集合的所有搜索索引的视图。
# server_selector ⇒ Mongo::ServerSelector

获取此集合的服务器选择器。
# system_collection? ⇒ 布尔 private

集合是否为系统集合。
#timeout_ms ⇒ Integer | nil private

该数据库或相应客户端的操作超时。
#update_many(filter, update, options = {}) ⇒ Result

更新集合中的文档。
#update_one(filter, update, options = {}) ⇒ Result

更新集合中的单个文档。
# watch (pipeline = [], options = {}) ⇒ ChangeStream

从 MongoDB Server 3.6版本开始，聚合框架支持“$changeStream”管道阶段。
# with (new_options) ⇒ Mongo::Collection

一个新的集合实例。
# write_concern ⇒ Mongo::WriteConcern

获取此集合的有效写关注。
# write_concern_with_session (session) ⇒ Mongo::WriteConcern private

在给定会话的情况下，获取用于对此集合进行操作的写关注（write concern）。

构造函数详情

#initialize (数据库, name, options = {}) ⇒`集合`

实例化一个新集合。

例子：

实例化一个新集合。

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

参数：

database ( Mongo::Database ) —

集合的数据库。
名称 ( string , Symbol ) —

collection名称。
选项（哈希） （默认为： {} ） —

集合选项。
opts (哈希) —

一组可自定义的选项

选项哈希 ( options )：

:read_concern （哈希） —
读关注（read concern）选项哈希，具有以下可选键：
- :level — 以符号表示的读取偏好（read preference）级别；有效值
```
are *:local*, *:majority*, and *:snapshot*
```
:read （哈希） —
读取偏好选项。哈希可能包含以下项目：
- ：模式—读取偏好（read preference），指定为符号；有效值为：主节点 (primary node in the replica set) 、 :primary_preferred 、 : secondary_preferred和:nearest 。
- :tag_sets – 哈希数组。
- :local_threshold 。
:session （会话） —

用于操作的会话。
:size （整数） —

固定大小固定大小集合的大小。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从数据库或客户端继承的。

引发：

( Error::InvalidCollectionName )

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 162

def 初始化(database, 名称, 选项 = {})
  提高 错误::InvalidCollectionName.new 除非 名称
  if 选项[:write] && 选项[:write_concern] && 选项[:write] != 选项[:write_concern]
    提高 ArgumentError, " 如果同时给出了 :write 和 : write_concern ，则它们必须相同： #{ options .inspect } "
  end
  @database = database
  @name = 名称.to_s.冻结
  @options = 选项.dup
  @timeout_ms = 选项.删除(:timeout_ms)
=begin WriteConcern 对象支持
  if @options[:write_concern].is_a?(WriteConcern::Base)
    # 缓存实例，以便我们不会不必要地重建它。
    @write_concern = @options[:write_concern]
    @options[:write_concern] = @write_concern.options
  end
=end
  @options.冻结
end

实例属性详细信息

#数据库⇒ `Mongo::Database` (readonly)

返回集合所在的数据库。

( Mongo::Database ) —

集合所在的数据库。

由于：

2.0.0



46
47
48

# File 'lib/ Mongo/ 集合.rb', line 46

def database
  @database
end

# name ⇒ `string` (readonly)

返回集合的名称。

( string ) —

集合的名称。

由于：

2.0.0



49
50
51

# File 'lib/ Mongo/ 集合.rb', line 49

def 名称
  @name
end

# options ⇒`哈希`（只读）

返回集合选项。

(哈希) —

集合选项。

由于：

2.0.0



52
53
54

# File 'lib/ Mongo/ 集合.rb', line 52

def 选项
  @options
end

实例方法详细信息

# == (other) ⇒ `true | false`

检查集合是否等于另一个对象。将检查名称和数据库是否相等。

例子：

检查集合相等性。

collection == other

参数：

其他 ( Object ) —

要检查的对象。

( true | false ) —

如果对象相等。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 89

def ==(其他)
  return false 除非 其他.is_a?(Collection)
  名称 == 其他.名称 && database == 其他.database && 选项 == 其他.选项
end

#aggregate (管道, options = {}) ⇒ `View::Aggregation`

对集合执行聚合。

例子：

执行聚合。

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

参数：

管道 ( Array<Hash> ) —

聚合管道。
选项（哈希） （默认为： {} ） —

聚合选项。

选项哈希 ( 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 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( View::Aggregation ) —

聚合对象。

由于：

2.1.0



568
569
570

# File 'lib/ Mongo/ 集合.rb', line 568

def 聚合(管道, 选项 = {})
  查看.new(self, {}, 选项).聚合(管道, 选项)
end

# bulk_write (requests, options = {}) ⇒ `BulkWrite::Result`

执行批处理批量写入操作。

例子：

执行批量写入。

collection.bulk_write(operations, options)

参数：

requests ( Enumerable<Hash> ) —

批量写入请求。
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( 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

# File 'lib/ Mongo/ 集合.rb', line 942

def bulk_write(requests, 选项 = {})
  批量写入.new(self, requests, 选项).执行
end

#固定大小？ ⇒ `true | false`

集合是否有上限？

例子：

集合是否有上限？

collection.capped?

( true | false ) —

如果集合有上限。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 321

def 封顶？
  database.list_collections(过滤器： { 名称： 名称 })
    .first
    &。dig('options', CAPPED) || false
end

# count (过滤 = nil, options = {}) ⇒ `Integer`

已弃用。

请改用#count_documents 或estimated_document_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 )：

:hint （哈希） —

要使用的索引。
:limit （整数） —

要计数的最大文档数。
:max_time_ms （整数） —

允许查询运行的最长时间（以毫秒为单位）。此选项已弃用，请改用 :timeout_ms。
:skip （整数） —

计数前要跳过的文档。
:read （哈希） —

读取偏好（read preference）选项。
:collation （哈希） —

要使用的排序规则。
:session （会话） —

要使用的会话。
:comment （对象） —

用户提供的待附加到该命令的注释。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( Integer ) —

文档计数。

由于：

2.1.0



685
686
687

# File 'lib/ Mongo/ 集合.rb', line 685

def 数数(筛选器 = nil, 选项 = {})
  查看.new(self, 筛选器 || {}, 选项).数数(选项)
end

# count_documents (过滤 = {}, options = {}) ⇒ `Integer`

获取与查询匹配的文档数。与已弃用的 #count 方法不同，这将返回与过滤匹配的确切文档数（如果未提供过滤，则返回集合中文档的确切数），而不是估计值。

使用 #estimated_document_count 来检索使用集合元数据的集合中文档数量的估计值。

参数：

筛选器（哈希） （默认为： {} ） —

匹配文档的过滤。
选项（哈希） （默认为： {} ） —

操作选项。

选项哈希 ( options )：

:skip （整数） —

要跳过的文档数量。
:hint （哈希） —

覆盖默认索引选择并强制MongoDB使用特定索引进行查询。需要服务器版本3.6 +。
:limit （整数） —

要计数的最大Docs数。
:max_time_ms （整数） —

允许命令运行的最长时间。
:read （哈希） —

读取偏好（read preference）选项。
:collation （哈希） —

要使用的排序规则。
:session （会话） —

要使用的会话。
:comment （对象） —

用户提供的待附加到该命令的注释。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( Integer ) —

文档计数。

由于：

2.6.0



719
720
721

# File 'lib/ Mongo/ 集合.rb', line 719

def count_documents(筛选器 = {}, 选项 = {})
  查看.new(self, 筛选器, 选项).count_documents(选项)
end

# create (opts = {}) ⇒`结果`

强制在数据库中创建集合。

例子：

强制创建集合。

collection.create

参数：

opts （哈希） （默认为： {} ） —

创建操作的选项。

选项哈希 ( opts )：

:capped ( true | false ) —

创建固定大小的集合。
:change_stream_pre_and_post_images （哈希） —
用于在创建的集合上启用前像和后像。哈希可能包含以下项目：
- :enabled — true 或 false。
:clustered_index （哈希） —
创建集群索引。此选项指定此集合应如何在_id上进行集群化。哈希可能包含以下项目：
- :key – 集群索引键字段。必须设立为 { _id: 1 }。
- :unique — 必须设立为 true。如果插入或更新的文档的聚集索引键值与索引中的现有值匹配，则该集合不会接受该文档。
- :name — 可选。唯一标识集群索引的名称。
:collation （哈希） —

创建集合时使用的排序规则。调用集合方法时，不会将此选项发送到服务器。
:encrypted_fields （哈希） —

描述可查询加密的加密字段的Queryable Encryption值。
:expire_after （整数） —

表示应在多少秒后删除旧时间序列数据的数字。
:max （整数） —

固定固定大小集合中的最大文档数。大小限制优先于最大值。
：管道 ( Array<Hash> ) —

管道阶段的大量。将此管道应用于 view_on集合或视图，将创建一个视图。
:session （会话） —

用于操作的会话。
:size （整数） —

固定大小固定大小集合的大小。
:time_series （哈希） —
创建时间序列集合。哈希可能包含以下项目：
- :timeField – 包含每个时间序列文档中日期的字段的名称。
- :metaField – 包含每个时间序列文档元数据的字段的名称。
- :粒度— 将粒度设置为与连续传入测量之间的时间跨度最接近的值。可能的值为“秒”（默认）、“分钟”和“小时”。
:validator （哈希） —

描述集合的文档验证选项的哈希值。
:view_on （ string ） —

要从中创建视图的源集合或视图的名称。
:write （哈希） —

已弃用。相当于 :write_concern 选项。
:write_concern （哈希） —

写关注（write concern）选项。可以是 :w => 整数|字符串、: fsync => 布尔值、:j => 布尔值。

(结果) —

命令的结果。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 382

def 创建(opts = {})
  # 将读取选项传递给 create 命令会导致其中断。
  # 过滤掉读取选项。 此处也不包括会话，因为它获取
  # 用于调用 with_session，并且不应该是
  # 操作。 如果将其传递给操作，则BSON将失败
  # 序列化。
  # TODO 将读取选项列表放入类级常量中，当
  # 我们找出它们的完整设立。
  选项 = 哈希[self.选项.合并(merge)(opts).拒绝 do |key, 值|
    %w(读 read_preference read_concern 会话).包括？(key.to_s)
  end]
  # 将Ruby选项转换为服务器样式。
  CREATE_COLLECTION_OPTIONS.每 do |ruby_key, server_key|
    if 选项.键？(ruby_key)
      选项[server_key] = 选项.删除(ruby_key)
    end
  end
  操作 = { :create => 名称 }.合并(merge)(选项)
  操作.删除(:write)
  操作.删除(:write_concern)
  客户端.发送(:with_session, opts) do |会话|
    write_concern = if opts[:write_concern]
      writeConcern.获取(opts[:write_concern])
    else
      self.write_concern
    end

    上下文 = 操作::上下文.new(
      客户端: 客户端,
      会话： 会话
    )
    也许_create_qe_collections(opts[:encrypted_fields], 客户端, 会话) do |encryption_fields|
      操作::创建.new(
        选择器： 操作,
        db_name: database.名称,
        write_concern: write_concern,
        会话： 会话,
        # 请注意，这些是集合选项，排序规则不是
        # 取自传递给 create 方法的选项。
        排序规则： 选项[:collation] || 选项[' collation '],
        encryption_fields: encryption_fields,
        validator: 选项[:validator],
      ).执行(
        next_primary(nil, 会话),
        上下文： 上下文
      )
    end
  end
end

# delete_many (filter = nil, options = {}) ⇒`结果`

从集合中删除文档。

例子：

从集合中删除多个文档。

collection.delete_many

参数：

筛选器（哈希） （默认为： nil ） —

要使用的过滤。
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( options )：

:collation （哈希） —

要使用的排序规则。
:session （会话） —

要使用的会话。
:hint （哈希 | string ） —

用于此操作的索引。可以指定为哈希值（例如 { _id : 1 }）或string （例如 “ ID ”）。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:let （哈希） —

要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

(结果) —

来自数据库的响应。

由于：

2.1.0



994
995
996

# File 'lib/ Mongo/ 集合.rb', line 994

def delete_many(筛选器 = nil, 选项 = {})
  find(筛选器, 选项).delete_many(选项)
end

# delete_one (过滤 = nil, options = {}) ⇒`结果`

从集合中删除文档。

例子：

从集合中删除单个文档。

collection.delete_one

参数：

筛选器（哈希） （默认为： nil ） —

要使用的过滤。
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( options )：

:collation （哈希） —

要使用的排序规则。
:session （会话） —

要使用的会话。
:hint （哈希 | string ） —

用于此操作的索引。可以指定为哈希值（例如 { _id : 1 }）或string （例如 “ ID ”）。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:let （哈希） —

要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

(结果) —

来自数据库的响应。

由于：

2.1.0



968
969
970

# File 'lib/ Mongo/ 集合.rb', line 968

def delete_one(筛选器 = nil, 选项 = {})
  find(筛选器, 选项).delete_one(选项)
end

# distinct (field_name, 过滤 = nil, options = {}) ⇒ `Array<Object>`

获取特定字段的非重复值列表。

例子：

获取不同的值。

collection.distinct('name')

参数：

field_name (符号, string ) —

字段的名称。
筛选器（哈希） （默认为： nil ） —

要从中检索非重复值的文档。
选项（哈希） （默认为： {} ） —

不同的命令选项。

选项哈希 ( options )：

:max_time_ms （整数） —

允许查询运行的最长时间（以毫秒为单位）。此选项已弃用，请改用 :timeout_ms。
:read （哈希） —

读取偏好（read preference）选项。
:collation （哈希） —

要使用的排序规则。
:session （会话） —

要使用的会话。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( Array<Object> ) —

非重复值列表。

由于：

2.1.0



771
772
773

# File 'lib/ Mongo/ 集合.rb', line 771

def distinct(field_name, 筛选器 = nil, 选项 = {})
  查看.new(self, 筛选器 || {}, 选项).distinct(field_name, 选项)
end

# drop (opts = {}) ⇒`结果`

注意：

如果集合不存在，则会抑制返回的错误。

删除集合。还会删除与集合关联的所有索引，以及关联的Queryable Encryption集合。

例子：

删除该集合。

collection.drop

参数：

opts （哈希） （默认为： {} ） —

删除操作的选项。
选项 (哈希) —

一组可自定义的选项

选项哈希 ( opts )：

:session （会话） —

用于操作的会话。
:write_concern （哈希） —

写关注（write concern）选项。
:encrypted_fields （哈希 | nil ） —

提供给“创建”集合助手的加密字段哈希。

(结果) —

命令的结果。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 454

def 删除(opts = {})
  客户端.with_session(opts) do |会话|
    也许_drop_emm_collections(opts[:encrypted_fields], 客户端, 会话) do
      temp_write_concern = write_concern
      write_concern = if opts[:write_concern]
        writeConcern.获取(opts[:write_concern])
      else
        temp_write_concern
      end
      上下文 = 操作::上下文.new(
        客户端: 客户端,
        会话： 会话,
        operation_timeups: operation_timeups(opts)
      )
      操作 = 操作::删除.new({
        选择器： { :drop => 名称 },
        db_name: database.名称,
        write_concern: write_concern,
        会话： 会话,
      })
      do_drop(操作, 会话, 上下文)
    end
  end
end

#estimated_document_count (options = {}) ⇒ `Integer`

使用集合元数据获取集合中文档的估计数量。

使用 #count_documents 检索集合中文档的确切数量，或对与筛选器匹配的文档进行计数。

参数：

选项（哈希） （默认为： {} ） —

操作选项。

选项哈希 ( options )：

:max_time_ms （整数） —

允许命令在服务器上运行的最长时间。
:read （哈希） —

读取偏好（read preference）选项。
:comment （对象） —

用户提供的待附加到该命令的注释。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( Integer ) —

文档计数。

由于：

2.6.0



744
745
746

# File 'lib/ Mongo/ 集合.rb', line 744

def estimated_document_count(选项 = {})
  查看.new(self, {}, 选项).estimated_document_count(选项)
end

# find (过滤 = nil, options = {}) ⇒ `CollectionView`

在集合中查找文档。

例子：

通过选择器在集合中查找文档。

collection.find(name: 1)

获取集合中的所有文档。

collection.find

参数：

筛选器（哈希） （默认为： nil ） —

查找中使用的筛选器。
选项（哈希） （默认为： {} ） —

用于查找的选项。

选项哈希 ( options )：

:allow_disk_use ( true | false ) —

设置为 true 时，服务器可以在执行查找操作时将临时数据写入磁盘。此选项仅在 MongoDB Server 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_replay ( true | false ) —

仅供内部复制使用，应用程序不应设立此选项。
:projection （哈希） —

结果设立的每个文档要包含或排除的字段。
:session （会话） —

要使用的会话。
:skip （整数） —

返回结果之前要跳过的Docs数。
:sort （哈希） —

对结果设立进行排序的键和方向对。
:timeout_mode ( :cursor_lifetime | :iteration ) —

如何解释 :timeout_ms（是应用于游标的生命周期，还是每次迭代）。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:let （哈希） —

要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

( CollectionView ) —

集合视图。

由于：

2.0.0



532
533
534

# File 'lib/ Mongo/ 集合.rb', line 532

def find(筛选器 = nil, 选项 = {})
  查看.new(self, 筛选器 || {}, 选项)
end

# find_one_and_delete (过滤, options = {}) = `" BSON::Document` ^?

通过 findAndModify 在数据库中查找单个文档并将其删除，同时返回原始文档。

例子：

查找一个文档并将其删除。

collection.find_one_and_delete(name: 'test')

参数：

筛选器 (哈希) —

要使用的过滤。
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( options )：

:max_time_ms （整数） —

允许查询运行的最长时间（以毫秒为单位）。此选项已弃用，请改用 :timeout_ms。
:projection （哈希） —

要在返回的文档中包含或排除的字段。
:sort （哈希） —

对结果设立进行排序的键和方向对。
:write_concern （哈希） —

写关注选项。默认为集合的写关注。
:collation （哈希） —

要使用的排序规则。
:session （会话） —

要使用的会话。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:hint （哈希 | string ） —

用于此操作的索引。可以指定为哈希值（例如 { _id : 1 }）或string （例如 “ ID ”）。
:let （哈希） —

要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

(BSON::Document, nil) —

该文档（如果找到）。

由于：

2.1.0



1157
1158
1159

# File 'lib/ Mongo/ 集合.rb', line 1157

def find_one_and_delete(筛选器, 选项 = {})
  find(筛选器, 选项).find_one_and_delete(选项)
end

# find_one_and_replace (过滤, replacement, options = {}) ⇒ `BSON::Document`

查找并替换单个文档，并返回原始文档，除非另有说明。

例子：

查找文档并将其替换，从而返回原始文档。

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

查找并替换文档，从而返回新文档。

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

参数：

筛选器 (哈希) —

要使用的过滤。
替换 ( BSON::Document ) —

替换文档。
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( options )：

:max_time_ms （整数） —

允许命令运行的最长时间（以毫秒为单位）。
:projection （哈希） —

要在返回的文档中包含或排除的字段。
:sort （哈希） —

对结果设立进行排序的键和方向对。
:return_document （符号） —

:before 或 :after。
：更新或插入（upsert） ( true | false ) —

如果文档不存在，是否进行更新或插入（upsert）或插入。
:bypass_document_validation ( true | false ) —

是否跳过文档级验证。
:write_concern （哈希） —

写关注选项。默认为集合的写关注。
:collation （哈希） —

要使用的排序规则。
:session （会话） —

要使用的会话。
:hint （哈希 | string ） —

用于此操作的索引。可以指定为哈希值（例如 { _id : 1 }）或string （例如 “ ID ”）。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:let （哈希） —

要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

( BSON::Document ) —

文档。

由于：

2.1.0



1243
1244
1245

# File 'lib/ Mongo/ 集合.rb', line 1243

def find_one_and_replace(筛选器, 替换, 选项 = {})
  find(筛选器, 选项).find_one_and_update(替换, 选项)
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 | Array<Hash> ) —

更新文档或管道。
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( options )：

:max_time_ms （整数） —

允许命令运行的最长时间（以毫秒为单位）。
:projection （哈希） —

要在返回的文档中包含或排除的字段。
:sort （哈希） —

对结果设立进行排序的键和方向对。
:return_document （符号） —

:before 或 :after。
：更新或插入（upsert） ( true | false ) —

如果文档不存在，是否进行更新或插入（upsert）或插入。
:bypass_document_validation ( true | false ) —

是否跳过文档级验证。
:write_concern （哈希） —

写关注选项。默认为集合的写关注。
:collation （哈希） —

要使用的排序规则。
:array_filters （数组） —

一设立筛选器，用于指定应将更新应用哪些大量元素。
:session （会话） —

要使用的会话。
:hint （哈希 | string ） —

用于此操作的索引。可以指定为哈希值（例如 { _id : 1 }）或string （例如 “ ID ”）。
:let （哈希） —

要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( BSON::Document ) —

文档。

由于：

2.1.0



1201
1202
1203

# File 'lib/ Mongo/ 集合.rb', line 1201

def find_one_and_update(筛选器, update, 选项 = {})
  find(筛选器, 选项).find_one_and_update(update, 选项)
end

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

获取此集合的所有索引的视图。可以迭代或具有更多操作。

例子：

获取索引视图。

collection.indexes

参数：

选项（哈希） （默认为： {} ） —

用于获取所有索引列表的选项。

选项哈希 ( options )：

:session （会话） —

要使用的会话。

( Index::View ) —

索引视图。

由于：

2.0.0



788
789
790

# File 'lib/ Mongo/ 集合.rb', line 788

def 索引(选项 = {})
  Index::查看.new(self, 选项)
end

# insert_many (documents, options = {}) ⇒`结果`

将提供的文档插入到集合中。

例子：

将文档插入collection。

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

参数：

文档 ( Enumerable<Hash> ) —

要插入的文档。
选项（哈希） （默认为： {} ） —

插入选项。

选项哈希 ( options )：

:bypass_document_validation ( true | false ) —

是否跳过文档级验证。
:comment （对象） —

用户提供的待附加到该命令的注释。
:ordered ( true | false ) —

操作是否应按顺序执行。
:session （会话） —

用于操作的会话。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:write_concern （哈希） —

写关注（write concern）选项。可以是 :w => 整数、: fsync => 布尔值、:j => 布尔值。

(结果) —

数据库响应包装器。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 910

def insert_many(文档, 选项 = {})
  查询缓存.clear_namespace(namespace)

  inserts = 文档.map{ |doc| { :insert_one => doc }}
  bulk_write(inserts, 选项)
end

# insert_one (文档, opts = {}) ⇒`结果`

将单个文档插入到集合中。

例子：

将文档插入集合中。

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

参数：

文档 (哈希) —

要插入的文档。
opts （哈希） （默认为： {} ） —

插入选项。
选项 (哈希) —

一组可自定义的选项

选项哈希 ( opts )：

:bypass_document_validation ( true | false ) —

是否跳过文档级验证。
:comment （对象） —

用户提供的待附加到该命令的注释。
:session （会话） —

用于操作的会话。
:write_concern （哈希） —

写关注（write concern）选项。可以是 :w => 整数、: fsync => 布尔值、:j => 布尔值。

(结果) —

数据库响应包装器。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 849

def insert_one(文档, opts = {})
  查询缓存.clear_namespace(namespace)

  客户端.with_session(opts) do |会话|
    write_concern = if opts[:write_concern]
      writeConcern.获取(opts[:write_concern])
    else
      write_concern_with_session(会话)
    end

    if 文档.nil?
      提高 ArgumentError, "要插入的文档不能为 nil "
    end

    上下文 = 操作::上下文.new(
      客户端: 客户端,
      会话： 会话,
      operation_timeups: operation_timeups(opts)
      )
    write_with_retry(write_concern, 上下文： 上下文) do |连接, txn_num, 上下文|
      操作::Insert.new(
        :documents => [ 文档 ],
        :db_name => database.名称,
        :coll_name => 名称,
        :write_concern => write_concern,
        :bypass_document_validation => !!opts[:bypass_document_validation],
        :options => opts,
        :id_generator => 客户端.选项[:id_generator],
        :session => 会话,
        :txn_num => txn_num,
        :comment => opts[:comment]
      ).execute_with_connection(连接, 上下文： 上下文)
    end
  end
end

#检查⇒ `string`

为集合进行美观打印的string检查。

例子：

检查集合。

collection.inspect

( string ) —

集合检查。

由于：

2.0.0



822
823
824

# File 'lib/ Mongo/ 集合.rb', line 822

def 检查
  " #<Mongo::Collection: 0 x #{ object_id } 命名空间= #{ 命名空间 } > "
end

#命名空间⇒ `string`

获取集合的完全限定命名空间。

例子：

获取完全限定的命名空间。

collection.namespace

( string ) —

集合命名空间。

由于：

2.0.0



1255
1256
1257

# File 'lib/ Mongo/ 集合.rb', line 1255

def namespace
  " #{ 数据库 . name } . #{ name } "
end

# operation_timeups (opts = {}) ⇒ `哈希`

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

返回在操作级别（如果有）上设立的timeout_ms 值，和/或在集合/数据库/客户端级别上设立的timeout_ms（如果有）。

(哈希) —

在操作级别上设立的timeout_ms 值（如果有），和/或在集合/数据库/客户端级别上设立的timeout_ms（如果有）。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 1280

def operation_timeups(opts = {})
  # TODO: 我们应该重新评估是否需要分别设置两次超时。
  {}.点击 do |结果|
    if opts[:timeout_ms].nil?
      结果[:inherited_timeout_ms] = timeout_ms
    else
      结果[:operation_timeout_ms] = opts.删除(:timeout_ms)
    end
  end
end

# parallel_scan (cursor_count, options = {}) ⇒ `Array< Cursor >`

对集合视图执行并行扫描。

返回最多包含 cursor_count 个可并发迭代的游标的列表。只要在扫描期间未修改集合，每个文档就会在游标的一个结果集中出现一次。

例子：

执行并行集合扫描。

collection.parallel_scan(2)

参数：

cursor_count ( Integer ) —

要返回的最大游标数。
选项（哈希） （默认为： {} ） —

并行扫描命令选项。

选项哈希 ( options )：

:max_time_ms （整数） —

允许查询运行的最长时间（以毫秒为单位）。此选项已弃用，请改用 :timeout_ms。
:session （会话） —

要使用的会话。
:timeout_mode ( :cursor_lifetime | :iteration ) —

如何解释 :timeout_ms（是应用于游标的生命周期，还是每次迭代）。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( Array< Cursor > ) —

游标数组。

由于：



1025
1026
1027

# File 'lib/ Mongo/ 集合.rb', line 1025

def parallel_scan(cursor_count, 选项 = {})
  find({}, 选项).parallel_scan(cursor_count, 选项)
end

# read_concern ⇒`哈希`

获取此集合实例的有效读关注。

如果集合选项中提供了读关注，则返回该读关注，否则将返回数据库的有效读关注。

例子：

获取读关注。

collection.read_concern

(哈希) —

读关注。

由于：

2.2.0



193
194
195

# File 'lib/ Mongo/ 集合.rb', line 193

def read_concern
  选项[:read_concern] || database.read_concern
end

# read_preference ⇒`哈希`

获取此集合的有效读取偏好（read preference）。

如果集合选项中提供了读取偏好，则返回该读取偏好，否则将返回数据库的有效读取偏好。

例子：

获取读取偏好。

collection.read_preference

(哈希) —

读取偏好（read preference）。

由于：

2.0.0



221
222
223

# File 'lib/ Mongo/ 集合.rb', line 221

def read_preference
  @read_preference ||= 选项[:read] || database.read_preference
end

# replace_one (过滤, replacement, options = {}) ⇒`结果`

用新文档替换集合中的单个文档。

例子：

替换单个文档。

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

参数：

筛选器 (哈希) —

要使用的过滤。
替换 (哈希) —

替换文档..
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( options )：

：更新或插入（upsert） ( true | false ) —

如果文档不存在，是否进行更新或插入（upsert）或插入。
:bypass_document_validation ( true | false ) —

是否跳过文档级验证。
:collation （哈希） —

要使用的排序规则。
:session （会话） —

要使用的会话。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:hint （哈希 | string ） —

用于此操作的索引。可以指定为哈希值（例如 { _id : 1 }）或string （例如 “ ID ”）。
:let （哈希） —

要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

(结果) —

来自数据库的响应。

由于：

2.1.0



1056
1057
1058

# File 'lib/ Mongo/ 集合.rb', line 1056

def replace_one(筛选器, 替换, 选项 = {})
  find(筛选器, 选项).replace_one(替换, 选项)
end

# search_indexes (options = {}) ⇒ `SearchIndex::View`

注意：

只能提供 ID 或名称之一；指定两者是错误的，尽管可以安全地省略两者。

获取此集合的所有搜索索引的视图。可以迭代或直接操作。如果给出了 id 或 name，则迭代器将仅返回指示的索引。对于所有其他操作，将忽略 ID 和名称。

参数：

选项（哈希） （默认为： {} ） —

用于配置视图的选项。

选项哈希 ( options )：

:id （ string ） —

要查询的特定索引的 ID（可选）
:name （ string ） —

要查询的特定索引的名称（可选）
:aggregate （哈希） —

要传递给聚合命令的选项哈希（可选）

( SearchIndex::View ) —

搜索索引视图。

由于：

2.0.0



810
811
812

# File 'lib/ Mongo/ 集合.rb', line 810

def search_indexes(选项 = {})
  SearchIndex::查看.new(self, 选项)
end

# server_selector ⇒ `Mongo::ServerSelector`

获取此集合的服务器选择器。

例子：

获取服务器选择器。

collection.server_selector

( Mongo::ServerSelector ) —

服务器选择器。

由于：

2.0.0



205
206
207

# File 'lib/ Mongo/ 集合.rb', line 205

def server_selector
  @server_selector ||= ServerSelector.获取(read_preference || database.server_selector)
end

# system_collection? ⇒`布尔`

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

集合是否为系统集合。

( Boolean ) —

系统是否为系统集合。

由于：

2.0.0



1264
1265
1266

# File 'lib/ Mongo/ 集合.rb', line 1264

def system_collection?
  名称.start_with?('系统。 ')
end

#timeout_ms ⇒ `Integer | nil`

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

返回此数据库或相应客户端的操作超时时间。

( Integer | nil ) —

该数据库或相应客户端的操作超时。

由于：

2.0.0



1272
1273
1274

# File 'lib/ Mongo/ 集合.rb', line 1272

def timeout_ms
  @timeout_ms || database.timeout_ms
end

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

更新集合中的文档。

例子：

更新集合中的多个文档。

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

参数：

筛选器 (哈希) —

要使用的过滤。
update ( Hash | Array<Hash> ) —

更新文档或管道。
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( options )：

：更新或插入（upsert） ( true | false ) —

如果文档不存在，是否进行更新或插入（upsert）或插入。
: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

# File 'lib/ Mongo/ 集合.rb', line 1089

def update_many(筛选器, update, 选项 = {})
  find(筛选器, 选项).update_many(update, 选项)
end

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

更新集合中的单个文档。

例子：

更新集合中的单个文档。

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

参数：

筛选器 (哈希) —

要使用的过滤。
update ( Hash | Array<Hash> ) —

更新文档或管道。
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( options )：

：更新或插入（upsert） ( true | false ) —

如果文档不存在，是否进行更新或插入（upsert）或插入。
: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

# File 'lib/ Mongo/ 集合.rb', line 1122

def update_one(筛选器, update, 选项 = {})
  find(筛选器, 选项).update_one(update, 选项)
end

# watch (管道 = [], options = {}) ⇒ `ChangeStream`

注意：

变更流只允许“多数”读关注（read concern）。

注意：

出于支持可恢复性的目的，此辅助方法优于使用 $changeStream 阶段运行原始聚合。

从 MongoDB Server 3.6版本开始，聚合框架支持“$changeStream”管道阶段。此阶段允许用户请求为特定集合的所有更改发送通知。

例子：

获取给定集合的变更通知。

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

参数：

管道 ( Array<Hash> ) （默认为： [] ） —

可选的附加过滤器操作符。
选项（哈希） （默认为： {} ） —

变更流选项。

选项哈希 ( options )：

:full_document （ string ） —

允许的值：nil、'default'、'updateLookup'、'whenAvailable'、'required'。

默认为不发送值（即 nil)，相当于“default”。默认情况下，部分更新的变更通知将包含描述文档变更的增量。

当设置为“updateLookup”时，部分更新的变更通知将包括描述文档更改的增量，以及自更改发生后某个时间以来已更改的整个文档的副本。

当设置为 'whenAvailable' 时，将变更流配置为返回替换和更新变更事件的已修改文档的后像（如果此事件的后像可用）。

当设置为“必需”时，行为与“whenAvailable”相同，只是如果后图像不可用，则会引发错误。
:full_document_before_change （ string ） —

允许的值：nil、'whenAvailable'、'required'、'off'。

默认为不发送值（即 nil)，相当于“off”。

当设置为 'whenAvailable' 时，将变更流配置为返回用于替换、更新和删除变更事件的已修改文档的前像（如果可用）。

当设置为“必需”时，行为与“whenAvailable”相同，只是如果前像不可用，则会引发错误。
:resume_after （ BSON::Document 、 Hash ） —

指定新变更流的逻辑起点。
:max_await_time_ms （整数） —

服务器等待新文档满足变更流查询的最长时间。
:batch_size （整数） —

批次中要返回的文档数量。
:collation （ BSON::Document 、 Hash ） —

要使用的排序规则。
:session （会话） —

要使用的会话。
:start_at_operation_time ( BSON::Timestamp ) —

仅返回在指定时间戳时或之后发生的更改。针对服务器运行的任何命令都将返回可在此处使用的集群时间。仅由服务器版本4.0 + 识别。
:comment （对象） —

用户提供的待附加到该命令的注释。
:show_expanded_events （布尔值） —

使服务器能够发送变更流事件的“扩展”列表。此标志集包含的其他事件列表包括：createIndexes、dropIndexes、modify、create、shardCollection、reshardCollection、refinedCollectionShardKey。
:timeout_mode ( :cursor_lifetime | :iteration ) —

如何解释 :timeout_ms（是应用于游标的生命周期，还是每次迭代）。
:timeout_ms （整数） —

操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( ChangeStream ) —

变更流对象。

由于：

2.5.0

# File 'lib/ Mongo/ 集合.rb', line 646

def 观看(管道 = [], 选项 = {})
  view_options = 选项.dup
  view_options[:cursor_type] = :tailable_await if 选项[:max_await_time_ms]
  查看::变更流.new(查看.new(self, {}, view_options), 管道, nil, 选项)
end

# with (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），指定为符号；有效值为：主节点 (primary node in the replica set) 、 :primary_preferred 、 : secondary_preferred和:nearest 。
- :tag_sets – 哈希数组。
- :local_threshold 。
:read_concern （哈希） —
读关注（read concern）选项哈希，具有以下可选键：
- :level — 以符号表示的读取偏好（read preference）级别；有效值
```
are *:local*, *:majority*, and *:snapshot*
```
:write （哈希） —

已弃用。相当于 :write_concern 选项。
:write_concern （哈希） —

写关注（write concern）选项。可以是 :w => 整数|字符串、: fsync => 布尔值、:j => 布尔值。

( Mongo::Collection ) —

一个新的集合实例。

由于：

2.1.0

# File 'lib/ Mongo/ 集合.rb', line 299

def 通过(new_options)
  new_options.密钥.每 do |k|
    提高 错误::UnchangeableCollectionOption.new(k) 除非 CHANGEABLE_OPTIONS.包括？(k)
  end
  选项 = @options.dup
  if 选项[:write] && new_options[:write_concern]
    选项.删除(:write)
  end
  if 选项[:write_concern] && new_options[:write]
    选项.删除(:write_concern)
  end
  Collection.new(database, 名称, 选项.update(new_options))
end

# write_concern ⇒ `Mongo::WriteConcern`

获取此集合的有效写关注。

如果集合选项中提供了写关注，则返回该写关注，否则将返回数据库的有效写关注。

例子：

获取写关注（write concern）。

collection.write_concern

( Mongo::WriteConcern ) —

写关注（write concern）。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 237

def write_concern
  @write_concern ||= writeConcern.获取(
    选项[:write_concern] || 选项[:write] || database.write_concern)
end

# write_concern_with_session (session) ⇒ `Mongo::WriteConcern`

此方法是私有 API 的一部分。 您应尽可能避免使用此方法，因为它将来可能会被删除或更改。

在给定会话的情况下，获取用于对此集合进行操作的写关注（write concern）。

如果会话位于事务中并且集合有未确认的写关注，请删除写关注的 :w 选项。否则，返回未修改的写关注。

( Mongo::WriteConcern ) —

写关注（write concern）。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', line 253

def write_concern_with_session(会话)
  wc = write_concern
  if 会话 && 会话.in_transaction?
    if wc && !wc.已确认？
      opts = wc.选项.dup
      opts.删除(:w)
      return writeConcern.获取(opts)
    end
  end
  wc
end

类：Mongo::Collection

Overview

在命名空间下定义

常量摘要折叠

QueryableEncryption中包含的常量

实例属性摘要折叠

实例方法摘要折叠

助手中包含的方法

QueryableEncryption中包含的方法

Retryable 中包含的方法

构造函数详情

#initialize (数据库, name, options = {}) ⇒集合

例子：

实例化一个新集合。

实例属性详细信息

#数据库⇒ Mongo::Database (readonly)

# name ⇒ string (readonly)

# options ⇒哈希（只读）

实例方法详细信息

# == (other) ⇒ true | false

例子：

检查集合相等性。

#aggregate (管道, options = {}) ⇒ View::Aggregation

例子：

执行聚合。

# bulk_write (requests, options = {}) ⇒ BulkWrite::Result

例子：

执行批量写入。

#固定大小？ ⇒ true | false

例子：

集合是否有上限？

# count (过滤 = nil, options = {}) ⇒ Integer

例子：

获取计数。

# count_documents (过滤 = {}, options = {}) ⇒ Integer

# create (opts = {}) ⇒结果

例子：

强制创建集合。

# delete_many (filter = nil, options = {}) ⇒结果

例子：

从集合中删除多个文档。

# delete_one (过滤 = nil, options = {}) ⇒结果

例子：

从集合中删除单个文档。

# distinct (field_name, 过滤 = nil, options = {}) ⇒ Array<Object>

例子：

获取不同的值。

# drop (opts = {}) ⇒结果

例子：

删除该集合。

#estimated_document_count (options = {}) ⇒ Integer

# find (过滤 = nil, options = {}) ⇒ CollectionView

例子：

通过选择器在集合中查找文档。

获取集合中的所有文档。

# find_one_and_delete (过滤, options = {}) = " BSON::Document ?

例子：

查找一个文档并将其删除。

# find_one_and_replace (过滤, replacement, options = {}) ⇒ BSON::Document

例子：

查找文档并将其替换，从而返回原始文档。

查找并替换文档，从而返回新文档。

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

例子：

查找并更新文档，同时返回原始文档。

查找并更新文档，返回更新后的文档。

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

例子：

获取索引视图。

# insert_many (documents, options = {}) ⇒结果

例子：

将文档插入collection。

# insert_one (文档, opts = {}) ⇒结果

例子：

将文档插入集合中。

#检查⇒ string

例子：

检查集合。

#命名空间⇒ string

例子：

#initialize (数据库, name, options = {}) ⇒`集合`

#数据库⇒ `Mongo::Database` (readonly)

# name ⇒ `string` (readonly)

# options ⇒`哈希`（只读）

# == (other) ⇒ `true | false`

#aggregate (管道, options = {}) ⇒ `View::Aggregation`

# bulk_write (requests, options = {}) ⇒ `BulkWrite::Result`

#固定大小？ ⇒ `true | false`

# count (过滤 = nil, options = {}) ⇒ `Integer`

# count_documents (过滤 = {}, options = {}) ⇒ `Integer`

# create (opts = {}) ⇒`结果`

# delete_many (filter = nil, options = {}) ⇒`结果`

# delete_one (过滤 = nil, options = {}) ⇒`结果`

# distinct (field_name, 过滤 = nil, options = {}) ⇒ `Array<Object>`

# drop (opts = {}) ⇒`结果`

#estimated_document_count (options = {}) ⇒ `Integer`

# find (过滤 = nil, options = {}) ⇒ `CollectionView`

# find_one_and_delete (过滤, options = {}) = `" BSON::Document` ^?

# find_one_and_replace (过滤, replacement, options = {}) ⇒ `BSON::Document`

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

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

# insert_many (documents, options = {}) ⇒`结果`

# insert_one (文档, opts = {}) ⇒`结果`

#检查⇒ `string`

#命名空间⇒ `string`

# operation_timeups (opts = {}) ⇒ `哈希`

# parallel_scan (cursor_count, options = {}) ⇒ `Array< Cursor >`

# read_concern ⇒`哈希`

# read_preference ⇒`哈希`

# replace_one (过滤, replacement, options = {}) ⇒`结果`

# search_indexes (options = {}) ⇒ `SearchIndex::View`

# server_selector ⇒ `Mongo::ServerSelector`

# system_collection? ⇒`布尔`

#timeout_ms ⇒ `Integer | nil`

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

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

# watch (管道 = [], options = {}) ⇒ `ChangeStream`

# with (new_options) ⇒ `Mongo::Collection`

# write_concern ⇒ `Mongo::WriteConcern`

# write_concern_with_session (session) ⇒ `Mongo::WriteConcern`