类：Mongo::Collection

继承：
对象
  • 对象
显示全部
扩展方式：
可转发
包括：
助手、 QueryableEncryption 、 Retryable
定义于：
build/Ruby-driver-v 2.19 /lib/mongo/collection.rb ,
build/Ruby-driver-v 2.19 /lib/mongo/collection/view.rb,
build/Ruby-driver-v 2.19 /lib/mongo/collection/helpers.rb,
build/Ruby-driver-v 2.19 /lib/mongo/collection/view/iterable.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/collection/view/可读.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/collection/view/writable.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/collection/view/immutable.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/collection/view/map_reduce.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/collection/view/aggregation.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/collection/view/explainable.rb,
build/Ruby-driver-v 2 . 19 /lib/mongo/collection/view/change_stream.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/collection/queryable_encryption.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/collection/view/builder/map_reduce.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/collection/view/builder/aggregation.rb,
build/Ruby-driver-v 2 。 19 /lib/mongo/collection/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

实例属性摘要折叠

实例方法摘要折叠

助手中包含的方法

#do_drop

QueryableEncryption中包含的方法

#maybe_create_qe_collections , #maybe_drop_emm_collections

Retryable 中包含的方法

#read_worker 、 #select_server 、 #write_worker

构造函数详情

#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 。

引发：

由于：

  • 2.0.0



158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 158

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
=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)

返回集合所在的数据库。

返回：

由于：

  • 2.0.0



46
47
48
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 46

def database
  @database
end

# name ⇒ string (readonly)

返回集合的名称。

返回：

  • ( string ) —

    集合的名称。

由于：

  • 2.0.0



49
50
51
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 49

def 名称
  @name
end

# options ⇒哈希（只读）

返回集合选项。

返回：

  • (哈希) —

    集合选项。

由于：

  • 2.0.0



52
53
54
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 52

def 选项
  @options
end

实例方法详细信息

# == (other) ⇒ true | false

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

例子：

检查集合相等性。

collection == other

参数：

  • 其他 ( Object ) —

    要检查的对象。

返回：

  • ( true | false ) —

    如果对象相等。

由于：

  • 2.0.0



89
90
91
92
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.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 （整数） —

    允许聚合运行的最长时间（以毫秒为单位）。

  • :use_cursor ( true | false ) —

    指示该命令是否将请求服务器使用游标提供结果。 请注意，从服务器版本3.6开始，聚合始终使用游标提供结果，因此该选项无效。

  • :session （会话） —

    要使用的会话。

返回：

由于：

  • 2.1.0



536
537
538
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 536

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 （会话） —

    用于这组操作的会话。

  • :let （哈希） —

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

返回：

由于：

  • 2.0.0



845
846
847
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 845

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

#固定大小？ ⇒ true | false

集合是否有上限？

例子：

集合是否有上限？

collection.capped?

返回：

  • ( true | false ) —

    如果集合有上限。

由于：

  • 2.0.0



316
317
318
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 316

def 封顶？
  database.read_command(:collstats => 名称).文档[0][CAPPED]
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 （整数） —

    允许命令运行的最长时间。

  • :skip （整数） —

    计数前要跳过的文档。

  • :read （哈希） —

    读取偏好（read preference）选项。

  • :collation （哈希） —

    要使用的排序规则。

  • :session （会话） —

    要使用的会话。

  • :comment （对象） —

    用户提供的待附加到该命令的注释。

返回：

  • ( Integer ) —

    文档计数。

由于：

  • 2.1.0



640
641
642
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 640

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 （对象） —

    用户提供的待附加到该命令的注释。

返回：

  • ( Integer ) —

    文档计数。

由于：

  • 2.6.0



670
671
672
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 670

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



373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 373

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 ”）。

  • :let （哈希） —

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

返回：

  • (结果) —

    来自数据库的响应。

由于：

  • 2.1.0



889
890
891
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 889

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 ”）。

  • :let （哈希） —

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

返回：

  • (结果) —

    来自数据库的响应。

由于：

  • 2.1.0



867
868
869
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 867

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 （整数） —

    允许命令运行的最长时间。

  • :read （哈希） —

    读取偏好（read preference）选项。

  • :collation （哈希） —

    要使用的排序规则。

  • :session （会话） —

    要使用的会话。

返回：

  • ( Array<Object> ) —

    非重复值列表。

由于：

  • 2.1.0



712
713
714
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 712

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



435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 435

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(客户端: 客户端, 会话： 会话)
      操作 = 操作::删除.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 （对象） —

    用户提供的待附加到该命令的注释。

返回：

  • ( Integer ) —

    文档计数。

由于：

  • 2.6.0



691
692
693
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 691

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 （整数） —

    允许查询运行的最长时间（以毫秒为单位）。

  • :modifiers （哈希） —

    包含修改查询输出或行为的元操作符的文档。

  • :no_cursor_timeout ( true | false ) —

    服务器通常会在不活动期（ 10分钟）后使空闲游标超时，以防止过度使用内存。 设置此选项可防止出现这种情况。

  • :oplog_replay ( true | false ) —

    仅供内部复制使用，应用程序不应设立此选项。

  • :projection （哈希） —

    结果设立的每个文档要包含或排除的字段。

  • :session （会话） —

    要使用的会话。

  • :skip （整数） —

    返回结果之前要跳过的Docs数。

  • :sort （哈希） —

    对结果设立进行排序的键和方向对。

  • :let （哈希） —

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

返回：

  • ( CollectionView ) —

    集合视图。

由于：

  • 2.0.0



501
502
503
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 501

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 （整数） —

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

  • :projection （哈希） —

    要在返回的文档中包含或排除的字段。

  • :sort （哈希） —

    对结果设立进行排序的键和方向对。

  • :write_concern （哈希） —

    写关注选项。 默认为集合的写关注。

  • :collation （哈希） —

    要使用的排序规则。

  • :session （会话） —

    要使用的会话。

  • :hint （哈希 | string ） —

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

  • :let （哈希） —

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

返回：

  • (BSON::Document, nil) —

    该文档（如果找到）。

由于：

  • 2.1.0



1027
1028
1029
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 1027

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 ”）。

  • :let （哈希） —

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

返回：

  • ( BSON::Document ) —

    文档。

由于：

  • 2.1.0



1105
1106
1107
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 1105

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 （哈希） —

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

返回：

  • ( BSON::Document ) —

    文档。

由于：

  • 2.1.0



1067
1068
1069
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 1067

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

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

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

例子：

获取索引视图。

collection.indexes

参数：

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

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

选项哈希 ( options )：

  • :session （会话） —

    要使用的会话。

返回：

  • ( View::Index ) —

    索引视图。

由于：

  • 2.0.0



729
730
731
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 729

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 （会话） —

    用于操作的会话。

  • :write_concern （哈希） —

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

返回：

  • (结果) —

    数据库响应包装器。

由于：

  • 2.0.0



817
818
819
820
821
822
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 817

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



764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 764

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(客户端: 客户端, 会话： 会话)
    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



741
742
743
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 741

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

#命名空间⇒ string

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

例子：

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

collection.namespace

返回：

  • ( string ) —

    集合命名空间。

由于：

  • 2.0.0



1117
1118
1119
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 1117

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

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

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

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

例子：

执行并行集合扫描。

collection.parallel_scan(2)

参数：

  • cursor_count ( Integer ) —

    要返回的最大游标数。

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

    并行扫描命令选项。

选项哈希 ( options )：

  • :max_time_ms （整数） —

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

  • :session （会话） —

    要使用的会话。

返回：

  • ( Array< Cursor > ) —

    游标数组。

由于：

  • 2.1



912
913
914
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 912

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

# read_concern ⇒哈希

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

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

例子：

获取读关注。

collection.read_concern

返回：

  • (哈希) —

    读关注。

由于：

  • 2.2.0



188
189
190
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 188

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

# read_preference ⇒哈希

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

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

例子：

获取读取偏好。

collection.read_preference

返回：

  • (哈希) —

    读取偏好（read preference）。

由于：

  • 2.0.0



216
217
218
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 216

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 （会话） —

    要使用的会话。

  • :hint （哈希 | string ） —

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

  • :let （哈希） —

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

返回：

  • (结果) —

    来自数据库的响应。

由于：

  • 2.1.0



939
940
941
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 939

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

# server_selector ⇒ Mongo::ServerSelector

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

例子：

获取服务器选择器。

collection.server_selector

返回：

由于：

  • 2.0.0



200
201
202
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 200

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

# system_collection? ⇒布尔

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

集合是否为系统集合。

返回：

  • ( Boolean ) —

    系统是否为系统集合。

由于：

  • 2.0.0



1126
1127
1128
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 1126

def system_collection?
  名称.start_with?('系统。 ')
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 （会话） —

    要使用的会话。

  • :hint （哈希 | string ） —

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

  • :let （哈希） —

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

返回：

  • (结果) —

    来自数据库的响应。

由于：

  • 2.1.0



968
969
970
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 968

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 （会话） —

    要使用的会话。

  • :hint （哈希 | string ） —

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

  • :let （哈希） —

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

返回：

  • (结果) —

    来自数据库的响应。

由于：

  • 2.1.0



997
998
999
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 997

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。

返回：

  • ( ChangeStream ) —

    变更流对象。

由于：

  • 2.5.0



607
608
609
610
611
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 607

def 观看(管道 = [], 选项 = {})
  view_options = 选项.dup
  view_options[:await_data] = true 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 => 布尔值。

返回：

由于：

  • 2.1.0



294
295
296
297
298
299
300
301
302
303
304
305
306
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 294

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

返回：

由于：

  • 2.0.0



232
233
234
235
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 232

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

# write_concern_with_session (session) ⇒ Mongo::WriteConcern

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

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

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

返回：

由于：

  • 2.0.0



248
249
250
251
252
253
254
255
256
257
258
 
# File 'build/Ruby-driver-v 2.19 /lib/mongo/collection.rb', line 248

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