类：Mongo::Operation::Result

继承：

对象

对象
Mongo::Operation::Result

显示全部

扩展方式：: 可转发

包括：: 可枚举

定义于：: lib/mongo/操作/result.rb、
lib/mongo/操作/shared/result/aggregatable.rb

Overview

传输协议回复的结果包装器。

一个操作有零个或一个回复。唯一产生零回复的操作是未确认的写入；所有其他操作都会产生一个回复。此类提供了一个对象，即使操作未生成回复（在这种情况下假定已成功），也可以对其进行操作（例如，检查操作是否成功）。

由于：

2.0.0

直接已知子类

删除::BulkResult、插入::BulkResult、更新::BulkResult

在命名空间下定义

模块： 可聚合

常量摘要折叠

CURSOR =

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

聚合中游标文档的字段名称。

由于：

2.2.0

'cursor'

CURSOR_ID =

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

游标文档中的游标 ID 字段。

由于：

2.2.0

'id'

FIRST_BATCH =

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

游标第一批的字段名称。

由于：

2.2.0

'firstBatch'

NEXT_BATCH =

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

下一批游标的字段名称。

由于：

2.2.0

'nextBatch'

NAMESPACE =

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

游标文档中的命名空间字段。

由于：

2.2.0

'ns'

N =

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

写入中更新的文档数量。

由于：

2.0.0

'n'

确定 =

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

结果中的 ok 状态字段。

由于：

2.0.0

'Ok'

结果 =

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

结果字段常量。

由于：

2.2.0

'结果'

实例属性摘要折叠

# connection ⇒ 对象只读
# connection_description ⇒ Server::Description 只读 private
对该结果所属服务器执行操作的服务器描述。
# connection_global_id ⇒ 对象只读 private
全局是针对此结果所针对的操作执行的连接的。
#context ⇒ Operation::Context | nil 只读 private
生成此结果时处于活动状态的操作上下文（如果有）。
#replies ⇒ Array<Protocol::Message> 只读 private
回复包装的传输协议回复。

实例方法摘要折叠

#已确认？ ⇒ true, false
结果是否已得到确认？
# cluster_time ⇒ ClusterTime | nil
获取服务器响应中报告的集群时间。
# cursor_id = "Integer" private
如果响应得到确认，则获取游标 ID。
# 个documents ⇒ Array<BSON::Document>
获取结果中的文档。
#每个{|Each| ... } ⇒ 枚举器
遍历回复中的文档。
# error ⇒ Error::OperationFailure::Family private
处理此结果期间将引发的（Error::OperationFailure::Family 的）异常实例。
# has_cursor_id? ⇒ true, false private
结果是否包含 cursor_id。
#initialize (replies, connection_description = nil, connection_global_id = nil, context: nil, connection: nil) ⇒ 结果构造函数 private
初始化新结果。
#检查⇒ string
获取结果的美观格式检查。
# labels ⇒ 数组 private
获取与结果关联的错误标签集。
#命名空间⇒ Nil private
获取游标的命名空间。
#可以吗？ ⇒ true, false
检查第一个文档的 ok字段。
# operation_time ⇒ 对象 | nil
获取服务器响应中报告的 optime。
#reply ⇒ Protocol::Message private
从结果中获取回复。
# returned_count ⇒ 整数
获取此批处理中服务器返回的文档数。
# snapshot_timestamp ⇒ 对象
# 成功? ⇒ true, false
如果结果是命令，则确定是否成功。
# topology_version ⇒ TopologyVersion | nil private
拓扑版本。
#validate! ⇒ Result private
通过检查是否存在任何错误来验证结果。
# write_concern_error? ⇒ 布尔 private
操作是否因写关注错误而失败。
# Write_count ⇒ Integer （也称为：#n）
获取服务器写入的文档数。

构造函数详情

#initialize (replies, connection_description = nil, connection_global_id = nil, context: nil, connection: nil) ⇒ `结果`

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

初始化新结果。

对于未确认的写入，请在回复中传递 nil。

For all other operations, replies must be a Protocol::Message instance or an array containing a single Protocol::Message instance.

参数：

回复 (Protocol::Message | Array<Protocol::Message> | nil) —
传输协议进行回复。
connection_description ( Server::Description | nil ) （默认为： nil ） —
MongoDB Server对执行此结果所属操作的服务器的描述。为了与现有的 mongo_kerberos 库兼容，该参数允许为 nil，但在驱动程序本身中不应始终为 nil。
connection_global_id （整数） （默认为： nil ） —
执行此结果所属操作的连接的全局 ID。
上下文 （Operation::Context | nil） （默认为： nil ） —
生成此结果时处于活动状态的上下文。

由于：

2.0.0

# File 'lib/ Mongo/operation/result.rb', line 104

def 初始化(回复, connection_description = nil, connection_global_id = nil, 上下文： nil, 连接： nil)
  @context = 上下文

  return 除非 回复

  if 回复.is_a?(阵列)
    提高 ArgumentError, " 仅支持一个（或零个）回复，因为 # { replies.length } } " if 回复.长度 != 1

    回复 = 回复.first
  else
    回复 = 回复
  end
  除非 回复.is_a?(protocol::message)
    提高 ArgumentError, " Argument 必须是 Message 实例，但是是#{ reply . class } : #{ reply .inspect } } "
  end

  @replies = [ 回复 ]
  @connection_description = connection_description
  @connection_global_id = connection_global_id
  @connection = 连接
end

实例属性详细信息

# 连接 ⇒ 对象（只读）

由于：

2.0.0



149
150
151

# File 'lib/ Mongo/operation/result.rb', line 149

def 连接
  @connection
end

# connection_description ⇒ `Server::Description` (readonly)

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

返回对该结果执行操作的服务器的MongoDB Server描述。

( Server::Description ) —
对该结果所属服务器执行操作的服务器描述。

由于：

2.0.0



135
136
137

# File 'lib/ Mongo/operation/result.rb', line 135

def connection_description
  @connection_description
end

# connection_global_id ⇒`对象`（只读）

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

返回针对此结果所属的操作执行的连接的全局。

( Object ) —
全局是针对此结果所针对的操作执行的连接的。

由于：

2.0.0



141
142
143

# File 'lib/ Mongo/operation/result.rb', line 141

def connection_global_id
  @connection_global_id
end

# context `="Operation::Context | nil（只读）`

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

返回生成此结果时处于活动状态的操作上下文（如果有）。

(Operation::Context | nil) —
生成此结果时处于活动状态的操作上下文（如果有）。

由于：

2.0.0



147
148
149

# File 'lib/ Mongo/operation/result.rb', line 147

def 上下文
  @context
end

#replies ⇒ `Array<Protocol::Message>` (readonly)

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

返回回复包装的传输协议回复。

(Array<Protocol::Message>) —
封装的传输协议回复。

由于：

2.0.0



129
130
131

# File 'lib/ Mongo/operation/result.rb', line 129

def 回复
  @replies
end

实例方法详细信息

#已确认？ ⇒ `true` , `false`

是否已确认结果？

( true , false ) —
如果结果得到确认。

由于：

2.0.0



161
162
163

# File 'lib/ Mongo/operation/result.rb', line 161

def 已确认？
  !!@replies
end

# cluster_time ⇒ `ClusterTime | nil`

获取服务器响应中报告的集群时间。

在版本2.9.0中进行了更改：此属性成为 ClusterTime 的实例，而 ClusterTime 是 BSON::Document 的子类。以前它是 BSON::Document 的实例。

例子：

获取集群时间。

result.cluster_time

( ClusterTime | nil ) —
集群时间文档。

由于：

2.5.0



427
428
429

# File 'lib/ Mongo/operation/result.rb', line 427

def cluster_time
  first_document && ClusterTime[first_document[' $clusterTime ']]
end

# cursor_id = " `Integer` "

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

注意：

游标 ID 为0表示服务器上没有游标。

如果响应得到确认，则获取游标 ID。

例子：

获取游标 ID。

result.cursor_id

( Integer ) —
游标 ID。

由于：

2.0.0



185
186
187

# File 'lib/ Mongo/operation/result.rb', line 185

def cursor_id
  已确认？ ? 回复.last.cursor_id : 0
end

# 个documents ⇒ `Array<BSON::Document>`

获取结果中的文档。

例子：

获取文档。

result.documents

( Array<BSON::Document> ) —
文档。

由于：

2.0.0

# File 'lib/ Mongo/operation/result.rb', line 209

def 文档
  if 已确认？
    回复.flat_map(和:documents)
  else
    []
  end
end

#每个{|Each| ... } ⇒`枚举器`

遍历回复中的文档。

例子：

遍历文档。

result.each do |doc|
  p doc
end

收益参数：

每个 ( BSON::Document ) —
结果中的文档。

(枚举器) —
枚举器。

由于：

2.0.0



230
231
232

# File 'lib/ Mongo/operation/result.rb', line 230

def 每(和块)
  文档.每(和块)
end

#error ⇒ `Error::OperationFailure::Family`

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

处理此结果期间将引发的（Error::OperationFailure::Family 的）异常实例。

仅当结果不成功时才应调用此方法。

(Error::OperationFailure::Family) —
异常。

由于：

2.0.0

# File 'lib/ Mongo/operation/result.rb', line 344

def 错误
  @error ||= operation_failure_class.new(
    解析器.message,
    self,
    代码： 解析器.代码,
    code_name: 解析器.code_name,
    write_concern_error_document: 解析器.write_concern_error_document,
    write_concern_error_code: 解析器.write_concern_error_code,
    write_concern_error_code_name: 解析器.write_concern_error_code_name,
    write_concern_error_labels: 解析器.write_concern_error_labels,
    标签： 解析器.labels,
    wtimeout: 解析器.wtimeout,
    connection_description: connection_description,
    文档: 解析器.文档,
    server_message: 解析器.server_message
  )
end

# has_cursor_id? ⇒ `true` , `false`

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

结果是否包含 cursor_id

( true , false ) —
如果结果包含 cursor_id。

由于：

2.0.0



170
171
172

# File 'lib/ Mongo/operation/result.rb', line 170

def has_cursor_id?
  已确认？ && 回复.last.respond_to?(:cursor_id)
end

#检查⇒ `string`

获取结果的美观格式检查。

例子：

检查结果。

result.inspect

( string ) —
检查。

由于：

2.0.0



243
244
245

# File 'lib/ Mongo/operation/result.rb', line 243

def 检查
  " #< #{ self . class . name } : 0 x #{ object_id } documents= #{ documents } > "
end

# labels ⇒`数组`

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

获取与结果关联的错误标签集。

例子：

获取标签。

result.labels

( Array ) —
labels 标签集。

由于：

2.7.0



440
441
442

# File 'lib/ Mongo/operation/result.rb', line 440

def labels
  @labels ||= 解析器.labels
end

#命名空间⇒ `Nil`

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

获取游标的命名空间空间。该方法应在结果类中定义，其中“ns”在服务器响应中。

( Nil )

由于：

2.0.0



196
197
198

# File 'lib/ Mongo/operation/result.rb', line 196

def namespace
  nil
end

#可以吗？ ⇒ `true` , `false`

检查第一个文档的 ok字段。

例子：

检查 ok 字段。

result.ok?

( true , false ) —
如果命令返回正常。

由于：

2.1.0

# File 'lib/ Mongo/operation/result.rb', line 308

def 确定吗？
  # first_document[OK] 是一个浮点数，服务器可以返回
  # 可以作为 BSON int 32 、 BSON int 64或 BSON double 。
  # 数字1可以精确地用浮点数表示，因此
  # 1.0 == 1将始终正确运行
  #（直到服务器返回1以外的其他内容为止）
  first_document[正常] == 1
end

# operation_time ⇒`对象 | nil`

获取服务器响应中报告的 optime。

例子：

获取optime 。

result.operation_time

( Object | nil ) —
optime值。

由于：

2.5.0



410
411
412

# File 'lib/ Mongo/operation/result.rb', line 410

def operation_time
  first_document && first_document[OPERATION_TIME]
end

#reply ⇒ `Protocol::Message`

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

从结果中获取回复。

如果没有回复（即该操作是未确认的写入），则返回 nil。

(Protocol::Message) —
第一个回复。

由于：

2.0.0

# File 'lib/ Mongo/operation/result.rb', line 256

def 回复
  return 除非 已确认？

  回复.first
end

# returned_count ⇒`整数`

获取此批处理中服务器返回的文档数。

( Integer ) —
返回的文档数量。

由于：

2.0.0

# File 'lib/ Mongo/operation/result.rb', line 268

def returned_count
  if 已确认？
    回复.number_returned
  else
    0
  end
end

# snapshot_timestamp ⇒`对象`

由于：

2.0.0

# File 'lib/ Mongo/operation/result.rb', line 451

def snapshot_timestamp
  return 除非 doc = 回复.文档.first

  doc[' cursor ']&。[ ]('atClusterTime') || doc['atClusterTime']
end

#成功？ ⇒ `true` , `false`

注意：

如果写入未被确认，则始终返回 true。

如果结果是命令，则确定是否成功。

例子：

命令成功吗？

result.successful?

( true , false ) —
如果命令成功。

由于：

2.0.0

# File 'lib/ Mongo/operation/result.rb', line 289

def 成功？
  return true 除非 已确认？

  if first_document.has_key?(正常)
    确定吗？ && 解析器.message.空？
  else
    !query_failure? && 解析器.message.空？
  end
end

# topology_version ⇒ `TopologyVersion | nil`

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

返回拓扑版本。

( TopologyVersion | nil ) —
拓扑版本。

由于：

2.0.0

# File 'lib/ Mongo/operation/result.rb', line 373

def topology_version
  除非 定义？(@topology_version)
    @topology_version = first_document['topologyVersion'] &&
                        TopologyVersion.new(first_document['topologyVersion'])
  end
  @topology_version
end

# validate! ⇒`结果`

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

注意：

这只检查写入错误，因为身份验证是在连接级别处理的，并且在创建结果之前，任何身份验证错误都会在那里引发。

通过检查是否存在任何错误来验证结果。

例子：

验证结果。

result.validate!

(结果) —
验证通过后的结果。

引发：

(Error::OperationFailure::Family) —
如果结果有误。

由于：

2.0.0



332
333
334

# File 'lib/ Mongo/operation/result.rb', line 332

def validate!
  成功？ ? self : Raise_operation_failure
end

# write_concern_error? ⇒`布尔`

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

操作是否因写关注错误而失败。

（布尔值）

由于：

2.0.0



447
448
449

# File 'lib/ Mongo/operation/result.rb', line 447

def write_concern_error?
  !!(first_document && first_document[' writeConcernError '])
end

# Write_count ⇒ `Integer`也称为： n

获取服务器写入的文档数。

例子：

获取写入的文档数。

result.written_count

( Integer ) —
写入的文档数量。

由于：

2.0.0

# File 'lib/ Mongo/operation/result.rb', line 390

def Write_Count
  if 已确认？
    first_document[N] || 0
  else
    0
  end
end

类：Mongo::Operation::Result

Overview

直接已知子类

在命名空间下定义

常量摘要折叠

实例属性摘要折叠

实例方法摘要折叠

构造函数详情

#initialize (replies, connection_description = nil, connection_global_id = nil, context: nil, connection: nil) ⇒ 结果

实例属性详细信息

# 连接 ⇒ 对象（只读）

# connection_description ⇒ Server::Description (readonly)

# connection_global_id ⇒对象（只读）

# context ="Operation::Context | nil（只读）

#replies ⇒ Array<Protocol::Message> (readonly)

实例方法详细信息

#已确认？ ⇒ true , false

# cluster_time ⇒ ClusterTime | nil

例子：

获取集群时间。

# cursor_id = " Integer "

例子：

获取游标 ID。

# 个documents ⇒ Array<BSON::Document>

例子：

获取文档。

#每个{|Each| ... } ⇒枚举器

例子：

遍历文档。

#error ⇒ Error::OperationFailure::Family

# has_cursor_id? ⇒ true , false

#检查⇒ string

例子：

检查结果。

# labels ⇒数组

例子：

获取标签。

#命名空间⇒ Nil

#可以吗？ ⇒ true , false

例子：

检查 ok 字段。

# operation_time ⇒对象 | nil

例子：

获取optime 。

#reply ⇒ Protocol::Message

# returned_count ⇒整数

# snapshot_timestamp ⇒对象

#成功？ ⇒ true , false

例子：

命令成功吗？

# topology_version ⇒ TopologyVersion | nil

# validate! ⇒结果

例子：

验证结果。

# write_concern_error? ⇒布尔

# Write_count ⇒ Integer也称为： n

例子：

获取写入的文档数。

#initialize (replies, connection_description = nil, connection_global_id = nil, context: nil, connection: nil) ⇒ `结果`

# connection_description ⇒ `Server::Description` (readonly)

# connection_global_id ⇒`对象`（只读）

# context `="Operation::Context | nil（只读）`

#replies ⇒ `Array<Protocol::Message>` (readonly)

#已确认？ ⇒ `true` , `false`

# cluster_time ⇒ `ClusterTime | nil`

# cursor_id = " `Integer` "

# 个documents ⇒ `Array<BSON::Document>`

#每个{|Each| ... } ⇒`枚举器`

#error ⇒ `Error::OperationFailure::Family`

# has_cursor_id? ⇒ `true` , `false`

#检查⇒ `string`

# labels ⇒`数组`

#命名空间⇒ `Nil`

#可以吗？ ⇒ `true` , `false`

# operation_time ⇒`对象 | nil`

#reply ⇒ `Protocol::Message`

# returned_count ⇒`整数`

# snapshot_timestamp ⇒`对象`

#成功？ ⇒ `true` , `false`

# topology_version ⇒ `TopologyVersion | nil`

# validate! ⇒`结果`

# write_concern_error? ⇒`布尔`

# Write_count ⇒ `Integer`也称为： n