类：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

'固定大小'

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

'ns'

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

%i[读 read_concern 写 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,
  encryption_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
* $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
允许用户请求就特定集合的所有更改发送通知。
# 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）级别；有效值为：:local、:大多数 和:快照
:read （哈希） —
读取偏好选项。哈希可能包含以下项目：
- :模式 --读取偏好（read preference）指定为符号；有效值为：主节点 (:primary node in the replica set),:primary_preferred、从节点(:secondary node from replica set),:secondary_preferred 和:nearest。
- :tag_sets — 数组哈希。
- :local_threshold 。
:session （会话） —
用于操作的会话。
:size （整数） —
固定大小固定大小集合的大小。
:timeout_ms （整数） —
操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从数据库或客户端继承的。

引发：

( Error::InvalidCollectionName )

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', 第 163 行

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)
  # WriteConcern对象支持
  # if @options[:write_concern].is_a?(WriteConcern::Base)
  # # 缓存实例，以便我们不会不必要地重建它。
  # @write_concern = @options[:write_concern]
  # @options[:write_concern] = @write_concern.options
  #       end
  @options.冻结
end

实例属性详细信息

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

返回集合所在的数据库。

( Mongo::Database ) —
集合所在的数据库。

由于：

2.0.0



44
45
46

# File 'lib/ Mongo/ 集合.rb', 第 44 行

def database
  @database
end

# name ⇒ `string` (readonly)

返回集合的名称。

( string ) —
集合的名称。

由于：

2.0.0



47
48
49

# File 'lib/ Mongo/ 集合.rb', 第 47 行

def 名称
  @name
end

# options ⇒`哈希`（只读）

返回集合选项。

(哈希) —
集合选项。

由于：

2.0.0



50
51
52

# File 'lib/ Mongo/ 集合.rb', 第 50 行

def 选项
  @options
end

实例方法详细信息

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

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

例子：

检查集合相等性。

collection == other

参数：

其他 ( Object ) —
要检查的对象。

( true | false ) —
如果对象相等。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', 第 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



567
568
569

# File 'lib/ Mongo/ 集合.rb', 第 567 行

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



939
940
941

# File 'lib/ Mongo/ 集合.rb', 第 939 行

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

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

集合是否有上限？

例子：

集合是否有上限？

collection.capped?

( true | false ) —
如果集合有上限。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', 第 317 行

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
* $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



681
682
683

# File 'lib/ Mongo/ 集合.rb', 第 681 行

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

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

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

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

参数：

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

选项哈希 ( options )：

:skip （整数） —
要跳过的文档数量。
:hint （哈希） —
覆盖默认索引选择并强制 MongoDB 使用特定索引进行查询。
:limit （整数） —
要计数的最大Docs数。
:max_time_ms （整数） —
允许命令运行的最长时间。
:read （哈希） —
读取偏好（read preference）选项。
:collation （哈希） —
要使用的排序规则。
:session （会话） —
要使用的会话。
:comment （对象） —
用户提供的待附加到该命令的注释。
:timeout_ms （整数） —
操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( Integer ) —
文档计数。

由于：

2.6.0



715
716
717

# File 'lib/ Mongo/ 集合.rb', 第 715 行

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', 第 378 行

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

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

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

从集合中删除文档。

例子：

从集合中删除多个文档。

collection.delete_many

参数：

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

选项哈希 ( options )：

:collation （哈希） —
要使用的排序规则。
:session （会话） —
要使用的会话。
:hint （哈希 | string ） —
用于此操作的索引。可以指定为哈希值（例如{ _id: 1 }) 或字符串（例如"ID").
:timeout_ms （整数） —
操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:let （哈希） —
要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

(结果) —
来自数据库的响应。

由于：

2.1.0



991
992
993

# File 'lib/ Mongo/ 集合.rb', 第 991 行

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

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

从集合中删除文档。

例子：

从集合中删除单个文档。

collection.delete_one

参数：

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

选项哈希 ( options )：

:collation （哈希） —
要使用的排序规则。
:session （会话） —
要使用的会话。
:hint （哈希 | string ） —
用于此操作的索引。可以指定为哈希值（例如{ _id: 1 }) 或字符串（例如"ID").
:timeout_ms （整数） —
操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:let （哈希） —
要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

(结果) —
来自数据库的响应。

由于：

2.1.0



965
966
967

# File 'lib/ Mongo/ 集合.rb', 第 965 行

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



767
768
769

# File 'lib/ Mongo/ 集合.rb', 第 767 行

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 ） —
提供给 create集合助手的加密字段哈希。

(结果) —
命令的结果。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', 第 451 行

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



740
741
742

# File 'lib/ Mongo/ 集合.rb', 第 740 行

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



531
532
533

# File 'lib/ Mongo/ 集合.rb', 第 531 行

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 （哈希） —
写关注（write concern）选项。默认为集合的写关注。
:collation （哈希） —
要使用的排序规则。
:session （会话） —
要使用的会话。
:timeout_ms （整数） —
操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:hint （哈希 | string ） —
用于此操作的索引。可以指定为哈希值（例如{ _id: 1 }) 或字符串（例如"ID").
:let （哈希） —
要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

(BSON::Document, nil) —
该文档（如果找到）。

由于：

2.1.0



1164
1165
1166

# File 'lib/ Mongo/ 集合.rb', 第 1164 行

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 （哈希） —
写关注（write concern）选项。默认为集合的写关注。
:collation （哈希） —
要使用的排序规则。
:session （会话） —
要使用的会话。
:hint （哈希 | string ） —
用于此操作的索引。可以指定为哈希值（例如{ _id: 1 }) 或字符串（例如"ID").
:timeout_ms （整数） —
操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。
:let （哈希） —
要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

( BSON::Document ) —
文档。

由于：

2.1.0



1250
1251
1252

# File 'lib/ Mongo/ 集合.rb', 第 1250 行

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 （哈希） —
写关注（write concern）选项。默认为集合的写关注。
:collation （哈希） —
要使用的排序规则。
:array_filters （数组） —
一设立筛选器，用于指定应将更新应用哪些大量元素。
:session （会话） —
要使用的会话。
:hint （哈希 | string ） —
用于此操作的索引。可以指定为哈希值（例如{ _id: 1 }) 或字符串（例如"ID").
:let （哈希） —
要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。
:timeout_ms （整数） —
操作超时（以毫秒为单位）。必须是非负整数。 0 的显式值表示无限。未设置默认值，这意味着该值是从集合、数据库或客户端继承的。

( BSON::Document ) —
文档。

由于：

2.1.0



1208
1209
1210

# File 'lib/ Mongo/ 集合.rb', 第 1208 行

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



784
785
786

# File 'lib/ Mongo/ 集合.rb', 第 784 行

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', 第 907 行

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', 第 845 行

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

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

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

#检查⇒ `string`

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

例子：

检查集合。

collection.inspect

( string ) —
集合检查。

由于：

2.0.0



818
819
820

# File 'lib/ Mongo/ 集合.rb', 第 818 行

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

#命名空间⇒ `string`

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

例子：

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

collection.namespace

( string ) —
集合命名空间。

由于：

2.0.0



1262
1263
1264

# File 'lib/ Mongo/ 集合.rb', 第 1262 行

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

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

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

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

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

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', 第 1287 行

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 > ) —
游标数组。

由于：



1022
1023
1024

# File 'lib/ Mongo/ 集合.rb', 第 1022 行

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

# read_concern ⇒`哈希`

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

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

例子：

获取读关注。

collection.read_concern

(哈希) —
读关注。

由于：

2.2.0



194
195
196

# File 'lib/ Mongo/ 集合.rb', 第 194 行

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

# read_preference ⇒`哈希`

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

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

例子：

获取读取偏好。

collection.read_preference

(哈希) —
读取偏好（read preference）。

由于：

2.0.0



222
223
224

# File 'lib/ Mongo/ 集合.rb', 第 222 行

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 }) 或字符串（例如"ID").
:let （哈希） —
要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。
:sort （哈希） —
指定在查询匹配多个文档时该操作替换的文档。与排序顺序匹配的第一个文档将被替换。只有 8.0 以上的服务器支持此选项。较旧的服务器将报告使用此选项的错误。

(结果) —
来自数据库的响应。

由于：

2.1.0



1058
1059
1060

# File 'lib/ Mongo/ 集合.rb', 第 1058 行

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

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

注意：

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

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

参数：

选项（哈希） （默认为： {} ） —
用于配置视图的选项。

选项哈希 ( options )：

:id （ string ） —
要查询的特定索引的 ID（可选）
:name （ string ） —
要查询的特定索引的名称（可选）
:aggregate （哈希） —
要传递给聚合命令的选项哈希（可选）

( SearchIndex::View ) —
搜索索引视图。

由于：

2.0.0



806
807
808

# File 'lib/ Mongo/ 集合.rb', 第 806 行

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

# server_selector ⇒ `Mongo::ServerSelector`

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

例子：

获取服务器选择器。

collection.server_selector

( Mongo::ServerSelector ) —
服务器选择器。

由于：

2.0.0



206
207
208

# File 'lib/ Mongo/ 集合.rb', 第 206 行

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

# system_collection? ⇒`布尔`

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

集合是否为系统集合。

( Boolean ) —
系统是否为系统集合。

由于：

2.0.0



1271
1272
1273

# File 'lib/ Mongo/ 集合.rb', 第 1271 行

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

#timeout_ms ⇒ `Integer | nil`

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

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

( Integer | nil ) —
该数据库或相应客户端的操作超时。

由于：

2.0.0



1279
1280
1281

# File 'lib/ Mongo/ 集合.rb', 第 1279 行

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 }) 或字符串（例如"ID").
:let （哈希） —
要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。

(结果) —
来自数据库的响应。

由于：

2.1.0



1091
1092
1093

# File 'lib/ Mongo/ 集合.rb', 第 1091 行

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 }) 或字符串（例如"ID").
:let （哈希） —
要在命令中使用的变量映射。有关详细信息，请参阅服务器文档。
:sort （哈希） —
指定在查询匹配多个文档时操作更新的文档。与排序顺序匹配的第一个文档将被更新。只有 8.0 以上的服务器支持此选项。较旧的服务器将报告使用此选项的错误。

(结果) —
来自数据库的响应。

由于：

2.1.0



1129
1130
1131

# File 'lib/ Mongo/ 集合.rb', 第 1129 行

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

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

注意：

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

注意：

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

允许用户请求就特定集合的所有更改发送通知。

例子：

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

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

参数：

管道 ( Array<Hash> ) （默认为： [] ） —
可选的附加过滤器操作符。
选项（哈希） （默认为： {} ） —
变更流选项。

选项哈希 ( options )：

:full_document （ string ） —
允许的值：nil、' 默认'、'updateLookup'、'whenAvailable'、'required'。

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

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

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

当设立为“必需”时，行为与“whenAvailable”相同，只是如果帖子图像不可用，则会引发错误。
:full_document_before_change （ string ） —
允许的值：nil、'whenAvailable'、'required'、'off'。

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

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

当设立为“必需”时，行为与“whenAvailable”相同，只是如果前像不可用，则会引发错误。
:resume_after （ BSON::Document 、 Hash ） —
指定新变更流的逻辑起点。
:max_await_time_ms （整数） —
服务器等待新文档满足变更流查询的最长时间。
:batch_size （整数） —
批次中要返回的文档数量。
:collation （ BSON::Document 、 Hash ） —
要使用的排序规则。
:session （会话） —
要使用的会话。
:start_at_operation_time ( BSON::Timestamp ) —
仅返回在指定时间戳时或之后发生的更改。针对服务器运行的任何命令都将返回可在此处使用的集群时间。
: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', 第 642 行

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 node from replica set),:secondary_preferred 和:nearest。
- :tag_sets — 数组哈希。
- :local_threshold 。
:read_concern （哈希） —
读关注（read concern）选项哈希，具有以下可选键：
- :level -- 以符号表示的读取偏好（read preference）级别；有效值为：:local、:大多数 和:快照
:write （哈希） —
已弃用。相当于 :write_concern 选项。
:write_concern （哈希） —
写关注（write concern）选项。可以是 :w => 整数|字符串、: fsync => 布尔值、:j => 布尔值。

( Mongo::Collection ) —
一个新的集合实例。

由于：

2.1.0

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

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

# write_concern ⇒ `Mongo::WriteConcern`

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

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

例子：

获取写关注（write concern）。

collection.write_concern

( Mongo::WriteConcern ) —
写关注（write concern）。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', 第 238 行

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

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

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

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

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

( Mongo::WriteConcern ) —
写关注（write concern）。

由于：

2.0.0

# File 'lib/ Mongo/ 集合.rb', 第 255 行

def write_concern_with_session(会话)
  wc = write_concern
  if 会话 && 会话.in_transaction? && wc && !wc.已确认？
    opts = wc.选项.dup
    opts.删除(:w)
    return writeConcern.获取(opts)
  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`