类：Mongo::Database

继承：

对象

对象
Mongo::Database

显示全部

扩展方式：: 可转发

包括：: 可重试

定义于：: lib/mongo/database.rb,
lib/mongo/database/view.rb 更多...

Overview

表示数据库服务器上的数据库以及可以在此级别对其执行的操作。

由于：

2.0.0

在命名空间下定义

类：查看

常量摘要折叠

ADMIN = 管理员数据库名称。 由于： 2.0.0

' admin '.冻结

命令 = 数据库命令操作的“集合”。 由于： 2.0.0

'$cmd'.冻结

DEFAULT_OPTIONS = 默认数据库选项。 由于： 2.0.0

选项::已编辑.new(:database => ADMIN).冻结

NAME =

已弃用。

数据库名称字段常量。

由于：

2.1.0

' name '.冻结

DATABASES = 数据库常量。 由于： 2.1.0

' databases '.冻结

命名空间 = 包含所有集合集合。 由于： 2.0.0

' system.namespaces '.冻结

实例属性摘要折叠

#client ⇒ Client 只读

客户端数据库客户端。
#名称⇒ string 只读

名称数据库的名称。
# options ⇒ 哈希只读

选项选项。

类方法摘要折叠

。创建(客户端) ⇒ 数据库 private

为提供的客户端创建一个数据库，以在不希望客户端的原始数据库实例相同时使用。

实例方法摘要折叠

# == (other) ⇒ true, false

检查数据库对象与另一个对象的相等性。
# [] (collection_name, options = {}) ⇒ Mongo::Collection （又作： # 集合）

按提供的名称获取此数据库中的集合。
#aggregate (pipeline, options = {}) ⇒ Collection::View::Aggregation

对数据库执行聚合。
#cluster ⇒ Mongo::Server

从集群中获取主节点 (primary node in the replica set)服务器。
# collection_names (options = {}) ⇒ Array<String>

获取数据库中所有非系统集合的名称。
# collections (options = {}) ⇒ Array<Mongo::Collection>

获取属于此数据库的所有非系统集合。
# command (operation, opts = {}) ⇒ Mongo::Operation::Result

对数据库执行命令。
# drop (options = {}) ⇒ 结果

删除数据库及其所有相关信息。
# fs (options = {}) ⇒ Grid::FSBucket

获取此数据库的网格“文件系统”。
#initialize (客户端, name, options = {}) ⇒ 数据库构造函数

实例化一个新的数据库对象。
#检查⇒ string

为数据库进行美观打印的string检查。
# list_collections (options = {}) ⇒ Array<Hash>

获取有关数据库中所有非系统集合的信息。
# operation_timeups (opts) ⇒ 哈希 private

在操作级别上设立的timeout_ms 值（如果有），和/或在集合/数据库/客户端级别上设立的timeout_ms（如果有）。
# read_command (operation, opts = {}) ⇒ 哈希 private

对数据库执行读取命令，必要时重试读取。
#timeout_ms ⇒ Integer | nil private

该数据库或相应客户端的操作超时。
# users ⇒ View::User

获取此数据库的用户视图。
# watch (pipeline = [], options = {}) ⇒ ChangeStream

从 MongoDB Server 3.6版本开始，聚合框架支持“$changeStream”管道阶段。

Retryable 中包含的方法

#read_worker 、 #select_server 、 #write_worker

构造函数详情

#initialize (客户端, name, options = {}) ⇒`数据库`

实例化一个新的数据库对象。

例子：

实例化数据库。

Mongo::Database.new(client, :test)

参数：

客户端 ( Mongo::Client ) —

驾驶员客户端。
名称 ( string , Symbol ) —

数据库的名称。
选项（哈希） （默认为： {} ） —

选项。

选项哈希 ( options )：

:timeout_ms （整数） —

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

引发：

( Mongo::Database::InvalidName ) —

如果名称为零。

由于：

2.0.0

[查看源代码]

# File 'lib/ Mongo/ 数据库.rb', line 362

def 初始化(客户端, 名称, 选项 = {})
  提高 错误::InvalidDatabaseName.new 除非 名称
  if Lint.已启用？ && !(名称.is_a?(字符串) || 名称.is_a?(符号))
    提高 "数据库名称必须是string或符号： #{ name } "
  end
  @client = 客户端
  @name = 名称.to_s.冻结
  @options = 选项.冻结
end

实例属性详细信息

# 客户端 ⇒`客户端`（只读）

返回客户端数据库客户端。

(客户端) —

客户端数据库客户端。

由于：

2.0.0


62
63
64

# File 'lib/ Mongo/ 数据库.rb', line 62

def 客户端
  @client
end

# name ⇒ `string` (readonly)

返回 name数据库的名称。

( string ) —

name数据库的名称。

由于：

2.0.0


65
66
67

# File 'lib/ Mongo/ 数据库.rb', line 65

def 名称
  @name
end

# options ⇒`哈希`（只读）

返回 options 选项。

(哈希) —

options 选项。

由于：

2.0.0


68
69
70

# File 'lib/ Mongo/ 数据库.rb', line 68

def 选项
  @options
end

类方法详细信息

。创建(客户端) ⇒`数据库`

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

为提供的客户端创建一个数据库，以在不希望客户端的原始数据库实例相同时使用。

例子：

为客户端创建数据库。

Database.create(client)

参数：

客户端 (客户端) —

要在其上创建的客户端。

(数据库) —

数据库。

由于：

2.0.0

[查看源代码]

# File 'lib/ Mongo/ 数据库.rb', line 543

def self.创建(客户端)
  database = Database.new(客户端, 客户端.选项[:database], 客户端.选项)
  客户端.instance_variable_set(:@database, database)
end

实例方法详细信息

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

检查数据库对象与另一个对象的相等性。将仅检查名称是否相同。

例子：

检查数据库相等性。

database == other

参数：

其他 ( Object ) —

要检查的对象。

( true , false ) —

如果对象相等。

由于：

2.0.0

[查看源代码]

# File 'lib/ Mongo/ 数据库.rb', line 94

def ==(其他)
  return false 除非 其他.is_a?(Database)
  名称 == 其他.名称
end

# [] (collection_name, options = {}) ⇒ `Mongo::Collection`也称为：集合

按提供的名称获取此数据库中的集合。

例子：

获取集合。

database[:users]

参数：

collection_name ( string , Symbol ) —

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

集合的选项。

( Mongo::Collection ) —

集合对象。

由于：

2.0.0

[查看源代码]

# File 'lib/ Mongo/ 数据库.rb', line 110

def [ ](collection_name, 选项 = {})
  if 选项[:server_api]
    提高 ArgumentError, '不能为集合对象指定 :server_api 选项。它只能在客户端级别指定'
  end
  Collection.new(self, collection_name, 选项)
end

#aggregate (pipeline, options = {}) ⇒ `Collection::View::Aggregation`

对数据库执行聚合。

例子：

执行聚合。

collection.aggregate([ { "$listLocalSessions" => {} } ])

参数：

管道 ( Array<Hash> ) —

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

聚合选项。

选项哈希 ( options )：

:allow_disk_use ( true , false ) —

如果在聚合期间允许使用磁盘，则设置为 true。
:batch_size （整数） —

批次中要返回的文档数量。
:bypass_document_validation ( true , false ) —

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

要使用的排序规则。
:comment （对象） —

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

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

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

用于该聚合的索引。
:session （会话） —

要使用的会话。

( Collection::View::Aggregation ) —

聚合对象。

由于：

2.10.0

[查看源代码]


450
451
452

# File 'lib/ Mongo/ 数据库.rb', line 450

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

#cluster ⇒ `Mongo::Server`

返回从集群中获取主节点 (primary node in the replica set)服务器。

( Mongo::Server ) —

从集群中获取主节点 (primary node in the replica set)服务器。

由于：

2.0.0

[查看源代码]


80
81

# File 'lib/ Mongo/ 数据库.rb', line 80

def_delegators :cluster,
:next_primary

# collection_names (options = {}) ⇒ `Array<String>`

注意：

返回的集合名称集取决于完成请求的 MongoDB 服务器的版本。

获取数据库中所有非系统集合的名称。

See https://mongodb.com/zh-cn/docs/manual/reference/command/listCollections/
for more information and usage.

参数：

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

选项哈希 ( options )：

:filter （哈希） —

返回的集合的筛选器。
:authorized_collections ( true , false ) —

一个标志，当设立为 true 并与 nameOnly: true 一起使用时，允许没有所需权限的用户在实施访问权限控制时运行命令
:comment （对象） —

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

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

( Array<String> ) —

集合的名称。

由于：

2.0.0

[查看源代码]


142
143
144

# File 'lib/ Mongo/ 数据库.rb', line 142

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

# collections (options = {}) ⇒ `Array< Mongo::Collection >`

注意：

返回的设立集取决于完成请求的MongoDB服务器的版本。

获取属于此数据库的所有非系统集合。

See https://mongodb.com/zh-cn/docs/manual/reference/command/listCollections/
for more information and usage.

参数：

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

选项哈希 ( options )：

:filter （哈希） —

返回的集合的筛选器。
:authorized_collections ( true , false ) —

一个标志，当设立为 true 并与 name_only: true 一起使用时，允许没有所需权限的用户在强制执行访问权限控制时运行命令。
:comment （对象） —

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

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

( Array< Mongo::Collection > ) —

集合。

由于：

2.0.0

[查看源代码]


203
204
205

# File 'lib/ Mongo/ 数据库.rb', line 203

def collections(选项 = {})
  collection_names(选项).map { |名称| 集合(名称) }
end

# command (operation, opts = {}) ⇒ `Mongo::Operation::Result`

对数据库执行命令。

例子：

执行命令。

database.command(:hello => 1)

参数：

操作 (哈希) —

要执行的命令。
opts （哈希） （默认为： {} ） —

命令选项。
选项 (哈希) —

一组可自定义的选项

选项哈希 ( opts )：

:read （哈希） —

此命令的读取偏好（read preference）。
:session （会话） —

用于此命令的会话。
:execution_options （哈希） —
要传递给执行此命令的代码的选项。这是内部选项，可能会发生变化。
- :deserialize_as_bson [ Boolean ] 是否尽可能使用BSON types而不是原生Ruby类型来反序列化对此命令的响应。

( Mongo::Operation::Result ) —

命令执行的结果。

由于：

2.0.0

[查看源代码]

# File 'lib/ Mongo/ 数据库.rb', line 229

def 命令(操作, opts = {})
  opts = opts.dup
  execution_opts = opts.删除(:execution_options) || {}

  txn_read_pref = if opts[:session] && opts[:session].in_transaction?
    opts[:session].txn_read_preference
  else
    nil
  end
  txn_read_pref ||= opts[:read] || ServerSelector::主节点
  Lint.validate_underscore_read_preference(txn_read_pref)
  选择器 = ServerSelector.获取(txn_read_pref)

  客户端.with_session(opts) do |会话|
    server = 选择器.select_server(集群, nil, 会话)
    op = 操作::命令.new(
      :selector => 操作,
      :db_name => 名称,
      :read => 选择器,
      :session => 会话
    )

    op.执行(server,
      上下文： 操作::上下文.new(
        客户端: 客户端,
        会话： 会话,
        operation_timeups: operation_timeups(opts)
      ),
      选项： execution_opts)
  end
end

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

删除数据库及其所有相关信息。

例子：

删除数据库。

database.drop

参数：

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

操作的选项。

选项哈希 ( options )：

:session （会话） —

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

写关注（write concern）选项。
:timeout_ms （整数） —

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

(结果) —

命令的结果。

由于：

2.0.0

[查看源代码]

# File 'lib/ Mongo/ 数据库.rb', line 322

def 删除(选项 = {})
  操作 = { :dropDatabase => 1 }
  客户端.with_session(选项) do |会话|
    write_concern = if 选项[:write_concern]
      writeConcern.获取(选项[:write_concern])
    else
      self.write_concern
    end
    操作::删除数据库.new({
      选择器： 操作,
      db_name: 名称,
      write_concern: write_concern,
      会话： 会话
    }).执行(
      next_primary(nil, 会话),
      上下文： 操作::上下文.new(
        客户端: 客户端,
        会话： 会话,
        operation_timeups: operation_timeups(选项)
      )
    )
  end
end

#fs(options = {}) ⇒ `Grid::FSBucket`

获取此数据库的网格“文件系统”。

参数：

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

GridFS选项。

选项哈希 ( options )：

:bucket_name （ string ） —

文件和数据段集合的前缀。
:chunk_size （整数） —

覆盖默认数据块大小。
:fs_name （ string ） —

文件和数据段集合的前缀。
:read （ string ） —

读取偏好（read preference）。
:session （会话） —

要使用的会话。
:write （哈希） —

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

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

( Grid::FSBucket ) —

数据库的GridFS 。

由于：

2.0.0

[查看源代码]


404
405
406

# File 'lib/ Mongo/ 数据库.rb', line 404

def fs(选项 = {})
  网格::FSBucket.new(self, 选项)
end

#检查⇒ `string`

为数据库进行美观打印的string检查。

例子：

检查数据库。

database.inspect

( string ) —

数据库检查。

由于：

2.0.0

[查看源代码]


380
381
382

# File 'lib/ Mongo/ 数据库.rb', line 380

def 检查
  " #<Mongo::Database: 0 x #{ object_id } name= #{ name } > "
end

# list_collections (options = {}) ⇒ `Array<Hash>`

注意：

返回的集合集以及每个集合的信息哈希模式取决于完成请求的 MongoDB 服务器版本。

获取有关数据库中所有非系统集合的信息。

See https://mongodb.com/zh-cn/docs/manual/reference/command/listCollections/
for more information and usage.

参数：

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

选项哈希 ( options )：

:filter （哈希） —

返回的集合的筛选器。
:name_only ( true , false ) —

指示命令是应仅返回集合/视图名称和类型，还是同时返回名称和其他信息
:authorized_collections ( true , false ) —

一个标志，当设立为 true 并与 nameOnly: true 一起使用时，允许没有所需权限的用户在实施访问权限控制时运行命令。
:comment （对象） —

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

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

( Array<Hash> ) —

信息哈希数组，数据库中的每个集合一个数组。

由于：

2.0.5

[查看源代码]


175
176
177

# File 'lib/ Mongo/ 数据库.rb', line 175

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

# operation_timeups (opts) ⇒ `哈希`

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

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

(哈希) —

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

由于：

2.0.0

[查看源代码]

# File 'lib/ Mongo/ 数据库.rb', line 560

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

# read_command (operation, opts = {}) ⇒`哈希`

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

对数据库执行读取命令，必要时重试读取。

参数：

操作 (哈希) —

要执行的命令。
opts （哈希） （默认为： {} ） —

命令选项。
选项 (哈希) —

一组可自定义的选项

选项哈希 ( opts )：

:read （哈希） —

此命令的读取偏好（read preference）。
:session （会话） —

用于此命令的会话。
:comment （对象） —

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

(哈希) —

命令执行的结果。

由于：

2.0.0

[查看源代码]

# File 'lib/ Mongo/ 数据库.rb', line 277

def read_command(操作, opts = {})
  txn_read_pref = if opts[:session] && opts[:session].in_transaction?
    opts[:session].txn_read_preference
  else
    nil
  end
  txn_read_pref ||= opts[:read] || ServerSelector::主节点
  Lint.validate_underscore_read_preference(txn_read_pref)
  偏好 = ServerSelector.获取(txn_read_pref)

  客户端.with_session(opts) do |会话|
    上下文 = 操作::上下文.new(
      客户端: 客户端,
      会话： 会话,
      operation_timeups: operation_timeups(opts)
    )
    read_with_retry(会话, 偏好, 上下文) do |server|
      操作::命令.new(
        选择器： 操作.dup,
        db_name: 名称,
        读取： 偏好,
        会话： 会话,
        comment: opts[:comment],
      ).执行(server, 上下文： 上下文)
    end
  end
end

#timeout_ms ⇒ `Integer | nil`

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

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

( Integer | nil ) —

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

由于：

2.0.0

[查看源代码]


552
553
554

# File 'lib/ Mongo/ 数据库.rb', line 552

def timeout_ms
  选项[:timeout_ms] || 客户端.timeout_ms
end

# users ⇒ `View::User`

获取此数据库的用户视图。

例子：

获取用户视图。

database.users

( View::User ) —

用户视图。

由于：

2.0.0

[查看源代码]


416
417
418

# File 'lib/ Mongo/ 数据库.rb', line 416

def 用户
  auth::user::查看.new(self)
end

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

注意：

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

注意：

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

从MongoDB 服务器 3.6版本开始，聚合框架支持“$changeStream”管道阶段。从版本4.0开始，此阶段允许用户请求为客户端数据库中发生的所有更改发送通知。

例子：

获取给定数据库的变更通知..

database.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.6.0

[查看源代码]

# File 'lib/ Mongo/ 数据库.rb', line 519

def 观看(管道 = [], 选项 = {})
  view_options = 选项.dup
  view_options[:cursor_type] = :tailable_await if 选项[:max_await_time_ms]

  mongo::Collection::查看::变更流.new(
    mongo::Collection::查看.new(集合(" #{ COMMAND } .aggregate "), {}, view_options),
    管道,
    mongo::Collection::查看::变更流::数据库,
    选项)
end

类：Mongo::Database

Overview

在命名空间下定义

常量摘要折叠

实例属性摘要折叠

类方法摘要折叠

实例方法摘要折叠

Retryable 中包含的方法

构造函数详情

#initialize (客户端, name, options = {}) ⇒数据库

例子：

实例化数据库。

实例属性详细信息

# 客户端 ⇒客户端（只读）

# name ⇒ string (readonly)

# options ⇒哈希（只读）

类方法详细信息

。创建(客户端) ⇒数据库

例子：

为客户端创建数据库。

实例方法详细信息

# == (other) ⇒ true , false

例子：

检查数据库相等性。

# [] (collection_name, options = {}) ⇒ Mongo::Collection也称为：集合

例子：

获取集合。

#aggregate (pipeline, options = {}) ⇒ Collection::View::Aggregation

例子：

执行聚合。

#cluster ⇒ Mongo::Server

# collection_names (options = {}) ⇒ Array<String>

# collections (options = {}) ⇒ Array< Mongo::Collection >

# command (operation, opts = {}) ⇒ Mongo::Operation::Result

例子：

执行命令。

# drop (options = {}) ⇒结果

例子：

删除数据库。

#fs(options = {}) ⇒ Grid::FSBucket

#检查⇒ string

例子：

检查数据库。

# list_collections (options = {}) ⇒ Array<Hash>

# operation_timeups (opts) ⇒ 哈希

# read_command (operation, opts = {}) ⇒哈希

#timeout_ms ⇒ Integer | nil

# users ⇒ View::User

例子：

获取用户视图。

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

例子：

获取给定数据库的变更通知..

#initialize (客户端, name, options = {}) ⇒`数据库`

# 客户端 ⇒`客户端`（只读）

# name ⇒ `string` (readonly)

# options ⇒`哈希`（只读）

。创建(客户端) ⇒`数据库`

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

# [] (collection_name, options = {}) ⇒ `Mongo::Collection`也称为：集合

#aggregate (pipeline, options = {}) ⇒ `Collection::View::Aggregation`

#cluster ⇒ `Mongo::Server`

# collection_names (options = {}) ⇒ `Array<String>`

# collections (options = {}) ⇒ `Array< Mongo::Collection >`

# command (operation, opts = {}) ⇒ `Mongo::Operation::Result`

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

#fs(options = {}) ⇒ `Grid::FSBucket`

#检查⇒ `string`

# list_collections (options = {}) ⇒ `Array<Hash>`

# operation_timeups (opts) ⇒ `哈希`

# read_command (operation, opts = {}) ⇒`哈希`

#timeout_ms ⇒ `Integer | nil`

# users ⇒ `View::User`

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