模块：Mongo::Collection::View::Readable

包含在：
Mongo::Collection::View
定义于：
构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb

Overview

定义集合视图的读取相关行为。

由于：

  • 2.0.0

实例方法摘要折叠

实例方法详细信息

#aggregate (管道, options = {}) ⇒聚合

在集合视图上执行聚合。

例子：

聚合文档。

view.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.0.0



60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第60行

def 聚合(管道, 选项 = {})
  选项 = @options.合并(merge)(选项) 除非 mongo.broken_view_options
  聚合 = 聚合(Aggregation).new(self, 管道, 选项)

  # 因为 $merge 和 $out 管道阶段将文档写入
  # 集合，执行时需要清除缓存。
  #
  # 选择清除整个缓存而不是一个命名空间，因为
  # $out 和 $merge 阶段不必写入同一命名空间
  # 在其上执行聚合。
  查询缓存.清除 if 聚合.写入?

  聚合
end

# allow_disk_use ⇒查看

允许服务器在执行查找操作时将临时数据写入磁盘。

返回：

  • ( View ) —

    新视图。

由于：

  • 2.0.0



79
80
81
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第79行

def allow_disk_use
  配置(:allow_disk_use, true)
end

# allow_partial_results ⇒查看

如果某些分片关闭，则允许查询获取部分结果。

例子：

允许部分结果。

view.allow_partial_results

返回：

  • ( View ) —

    新视图。

由于：

  • 2.0.0



91
92
93
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第91行

def allow_partial_results
  配置(:allow_partial_results, true)
end

# await_data ⇒查看

让查询的游标保持打开状态并等待数据。

例子：

等待游标上的数据。

view.await_data

返回：

  • ( View ) —

    新视图。

由于：

  • 2.0.0



103
104
105
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第103行

def await_data
  配置(:await_data, true)
end

# batch_size (batch_size = nil) ⇒ Integer , View

注意：

指定1或负数类似于设置限制。

MongoDB批处理结果中返回的文档数量。

例子：

设置批处理大小。

view.batch_size(5)

参数：

  • batch_size （整数） （默认为： nil ） —

    批处理结果的大小。

返回：

  • ( Integer , View ) —

    batch_size 值或新的View 。

由于：

  • 2.0.0



120
121
122
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第120行

def batch_size(batch_size = nil)
  配置(:batch_size, batch_size)
end

# comment (comment = nil) ⇒ string , View

注意：

将 profilingLevel 设置为2 ，评论将与查询一起记录在配置文件集合中。

将注释与查询关联。

例子：

添加评论。

view.comment('slow query')

参数：

  • comment （对象） （默认为： nil ） —

    与查询相关的注释。

返回：

  • ( string , View ) —

    注释或新的View 。

由于：

  • 2.0.0



138
139
140
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第138行

def comment(comment = nil)
  配置(:comment, comment)
end

# count (opts = {}) ⇒整数

已弃用。

请改用 #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_view.count

参数：

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

    操作选项。

选项哈希 ( opts )：

  • :skip （整数） —

    要跳过的文档数量。

  • :hint （哈希） —

    覆盖默认索引选择并强制 MongoDB 使用特定索引进行查询。

  • :limit （整数） —

    要计数的最大Docs数。

  • :max_time_ms （整数） —

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

  • :read （哈希） —

    读取偏好（read preference）选项。

  • :collation （哈希） —

    要使用的排序规则。

  • :session ( Mongo::Session ) —

    用于操作的会话。

  • :comment （对象） —

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

返回：

  • ( Integer ) —

    文档计数。

由于：

  • 2.0.0



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第170行

def 数数(opts = {})
  opts = @options.合并(merge)(opts) 除非 mongo.broken_view_options
  cmd = { :count => 集合.名称, :query => 筛选器 }
  cmd[:skip] = opts[:skip] if opts[:skip]
  cmd[:hint] = opts[:hint] if opts[:hint]
  cmd[:limit] = opts[:limit] if opts[:limit]
  if read_concern
    cmd[:readConcern] = 选项::映射器.transform_values_to_strings(
      read_concern)
  end
  cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
  mongo::Lint.validate_underscore_read_preference(opts[:read])
  read_pref = opts[:read] || read_preference
  选择器 = ServerSelector.获取(read_pref || server_selector)
  with_session(opts) do |会话|
    read_with_retry(会话, 选择器) do |server|
      操作::数数.new(
        选择器： cmd,
        db_name: database.名称,
        选项： {:limit => -1},
        读取： read_pref,
        会话： 会话,
        # 由于某种原因，排序规则在历史上被接受为
        # string key. 请注意，这不会被记录为有效用法。
        排序规则： opts[:collation] || opts[' collation '] || 排序规则,
        comment: opts[:comment],
      ).执行(server, 上下文： 操作::上下文.new(客户端: 客户端, 会话： 会话))
    end.n.to_i
  end
end

# count_documents (opts = {}) ⇒ Integer

获取集合中匹配文档的计数。

例子：

获取集合中的文档数。

collection_view.count

参数：

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

    操作选项。

  • 运维 (哈希) —

    一组可自定义的选项

选项哈希 ( opts )：

  • :skip （整数） —

    要跳过的文档数量。

  • :hint （哈希） —

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

  • :limit （整数） —

    要计数的最大Docs数。

  • :max_time_ms （整数） —

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

  • :read （哈希） —

    读取偏好（read preference）选项。

  • :collation （哈希） —

    要使用的排序规则。

  • :session ( Mongo::Session ) —

    用于操作的会话。

返回：

  • ( Integer ) —

    文档计数。

由于：

  • 2.6.0



223
224
225
226
227
228
229
230
231
232
233
234
235
236
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第223行

def count_documents(opts = {})
  opts = @options.合并(merge)(opts) 除非 mongo.broken_view_options
  管道 = [:'$match' => 筛选器]
  管道 << { :'$skip' => opts[:skip] } if opts[:skip]
  管道 << { :'$limit' => opts[:limit] } if opts[:limit]
  管道 << { :'$group' => { _id: 1, n: { :'$sum' => 1 } } }

  opts = opts.slice(:hint, :max_time_ms, :read, :collation, :session, :comment)
  opts[:collation] ||= 排序规则

  first = 聚合(管道, opts).first
  return 0 除非 first
  first['n'].to_i
end

# cursor_type (type = nil) ⇒ :tailable , ...

要使用的游标类型。 可以是 :tailable 或 :tailable_await。

例子：

设置游标类型。

view.cursor_type(:tailable)

参数：

  • 类型 ( :tailable , :tailable_await ) （默认为： nil ） —

    游标类型。

返回：

  • ( :tailable , :tailable_await , View ) —

    游标类型设置或新的View 。

由于：

  • 2.3.0



626
627
628
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第626行

def cursor_type(类型 = nil)
  配置(:cursor_type, 类型)
end

# distinct (field_name, opts = {}) ⇒ Array<Object>

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

例子：

获取不同的值。

collection_view.distinct('name')

参数：

  • field_name ( string , Symbol ) —

    字段的名称。

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

    distinct 命令的选项。

  • 选项 (哈希) —

    一组可自定义的选项

选项哈希 ( opts )：

  • :max_time_ms （整数） —

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

  • :read （哈希） —

    读取偏好（read preference）选项。

  • :collation （哈希） —

    要使用的排序规则。

返回：

  • ( Array<Object> ) —

    非重复值列表。

由于：

  • 2.0.0



317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第317行

def distinct(field_name, opts = {})
  if field_name.nil?
    提高 ArgumentError, '用于非重复操作的字段名称不得为 nil '
  end
  opts = @options.合并(merge)(opts) 除非 mongo.broken_view_options
  cmd = { :distinct => 集合.名称,
          :key => field_name.to_s,
          :query => 筛选器, }
  cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
  if read_concern
    cmd[:readConcern] = 选项::映射器.transform_values_to_strings(
      read_concern)
  end
  mongo::Lint.validate_underscore_read_preference(opts[:read])
  read_pref = opts[:read] || read_preference
  选择器 = ServerSelector.获取(read_pref || server_selector)
  with_session(opts) do |会话|
    read_with_retry(会话, 选择器) do |server|
      操作::distinct.new(
        选择器： cmd,
        db_name: database.名称,
        选项： {:limit => -1},
        读取： read_pref,
        会话： 会话,
        comment: opts[:comment],
        # 由于某种原因，排序规则在历史上被接受为
        # string key. 请注意，这不会被记录为有效用法。
        排序规则： opts[:collation] || opts[' collation '] || 排序规则,
      ).执行(server, 上下文： 操作::上下文.new(客户端: 客户端, 会话： 会话))
    end.first[' values ']
  end
end

#estimated_document_count (opts = {}) ⇒ Integer

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

例子：

获取集合中的文档数。

collection_view.estimated_document_count

参数：

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

    操作选项。

选项哈希 ( opts )：

  • :max_time_ms （整数） —

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

  • :read （哈希） —

    读取偏好（read preference）选项。

  • :comment （对象） —

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

返回：

  • ( Integer ) —

    文档计数。

由于：

  • 2.6.0



254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第254行

def estimated_document_count(opts = {})
  除非 查看.筛选器.空？
    提高 ArgumentError, “使用筛选器查询时无法调用estimated_document_count ”
  end

  %i[limit 跳过].每 do |opt|
    if 选项.键？(opt) || opts.键？(opt)
      提高 ArgumentError, " 使用 #{ opt} 进行查询时，无法调用estimated_document_count "
    end
  end

  opts = @options.合并(merge)(opts) 除非 mongo.broken_view_options
  mongo::Lint.validate_underscore_read_preference(opts[:read])
  read_pref = opts[:read] || read_preference
  选择器 = ServerSelector.获取(read_pref || server_selector)
  with_session(opts) do |会话|
    read_with_retry(会话, 选择器) do |server|
      上下文 = 操作::上下文.new(客户端: 客户端, 会话： 会话)
      cmd = { 计数： 集合.名称 }
      cmd[:maxTimeMS] = opts[:max_time_ms] if opts[:max_time_ms]
      if read_concern
        cmd[:readConcern] = 选项::映射器.transform_values_to_strings(read_concern)
      end
      结果 = 操作::数数.new(
        选择器： cmd,
        db_name: database.名称,
        读取： read_pref,
        会话： 会话,
        comment: opts[:comment],
      ).执行(server, 上下文： 上下文)
      结果.n.to_i
    end
  end
救援 错误::OperationFailure => 排除
  if 排除.代码 == 26
    # NamespaceNotFound
    # 这应该只发生在聚合管道路径上
    #（服务器4.9 +）。 以前的服务器应返回0 （表示不存在）
    # collections.
    0
  else
    提高
  end
end

#hint (hint = nil) ⇒ Hash , View

MongoDB 将强制用于查询的索引。

例子：

设置索引提示。

view.hint(name: 1)

参数：

  • 提示 （哈希） （默认为： nil ） —

    用于查询的索引。

返回：

  • （哈希、视图） —

    提示或新的View 。

由于：

  • 2.0.0



360
361
362
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第360行

def 提示(提示 = nil)
  配置(:hint, 提示)
end

#limit(limit = nil) ⇒ Integer, View

从查询中返回的最大Docs数。

例子：

设置限制。

view.limit(5)

参数：

  • limit （整数） （默认为： nil ） —

    要返回的Docs数量。

返回：

  • ( Integer , View ) —

    限制或新的View 。

由于：

  • 2.0.0



374
375
376
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第374行

def limit(limit = nil)
  配置(:limit, limit)
end

# map_reduce (map, reduce, options = {}) ⇒ MapReduce

在集合视图上执行 map/reduce 操作。

例子：

执行 map/reduce。

view.map_reduce(map, reduce)

参数：

  • map ( string ) —

    地图JavaScript函数。

  • 化简(reduce) ( string ) —

    reduce JavaScript函数。

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

    map/reduce 选项。

返回：

由于：

  • 2.0.0



390
391
392
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第390行

def map_reduce(map, 化简(reduce), 选项 = {})
  MapReduce.new(self, map, 化简(reduce), @options.合并(merge)(选项))
end

# max_await_time_ms (max = nil) ⇒ Integer , View

在游标上处理获取更多操作的累积时间限制（以毫秒为单位）。

例子：

设置最大等待时间（毫秒）值。

view.max_await_time_ms(500)

参数：

  • Max （整数） （默认为： nil ） —

    最长时间（以毫秒为单位）。

返回：

  • ( Integer , View ) —

    最大等待时间（毫秒）值或新的View 。

由于：

  • 2.1.0



598
599
600
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第598行

def max_await_time_ms(Max = nil)
  配置(:max_await_time_ms, Max)
end

# max_scan (value = nil) ⇒ Integer , View

已弃用。

从 MongoDB 服务器版本4.0开始，此选项已弃用。

设置要扫描的最大文档数。

例子：

设置最大扫描值。

view.max_scan(1000)

参数：

  • 值 （整数） （默认为： nil ） —

    要扫描的最大数量。

返回：

  • ( Integer , View ) —

    值或新的View 。

由于：

  • 2.0.0



407
408
409
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第407行

def max_scan(值 = nil)
  配置(:max_scan, 值)
end

# max_time_ms (max = nil) ⇒ Integer , View

对游标进行处理操作的累积时间限制（以毫秒为单位）。

例子：

设置最长时间（毫秒）值。

view.max_time_ms(500)

参数：

  • Max （整数） （默认为： nil ） —

    最长时间（以毫秒为单位）。

返回：

  • ( Integer , View ) —

    最长时间毫秒值或新的View 。

由于：

  • 2.1.0



612
613
614
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第612行

def max_time_ms(Max = nil)
  配置(:max_time_ms, Max)
end

# max_value (value = nil) ⇒ Hash , View

将最大值设置为Atlas Search 。

例子：

设置最大值。

view.max_value(_id: 1)

参数：

  • 值 （哈希） （默认为： nil ） —

    最大值字段和值。

返回：

  • （哈希、视图） —

    值或新的View 。

由于：

  • 2.1.0



421
422
423
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第421行

def max_value(值 = nil)
  配置(:max_value, 值)
end

# min_value (value = nil) ⇒ Hash , View

将最小值设置为搜索。

例子：

设置最小值。

view.min_value(_id: 1)

参数：

  • 值 （哈希） （默认为： nil ） —

    最小字段和值。

返回：

  • （哈希、视图） —

    值或新的View 。

由于：

  • 2.1.0



435
436
437
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第435行

def min_value(值 = nil)
  配置(:min_value, 值)
end

#modifiers(doc = nil) ⇒ Hash, View

如果不带参数或使用 nil 参数调用，则返回当前视图的传统 (OP_QUERY)服务器修饰符。 如果使用非 nil 参数（必须是哈希或子类）调用，则将提供的修饰符合并到当前视图中。 输入哈希中允许使用string键和符号键。

例子：

设置修饰符文档。

view.modifiers(:$orderby => Mongo::Index::ASCENDING)

参数：

  • doc （哈希） （默认为： nil ） —

    修饰符文档。

返回：

  • （哈希、视图） —

    修饰符文档或新的View 。

由于：

  • 2.1.0



579
580
581
582
583
584
585
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第579行

def modifiers(doc = nil)
  if doc.nil?
    操作::find::生成器::Modifiers.map_server_modifiers(选项)
  else
    new(选项.合并(merge)(操作::find::生成器::Modifiers.map_driver_options(BSON::文档.new(doc))))
  end
end

# no_cursor_timeout ⇒查看

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

例子：

将游标设置为不超时。

view.no_cursor_timeout

返回：

  • ( View ) —

    新视图。

由于：

  • 2.0.0



448
449
450
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第448行

def no_cursor_timeout
  配置(:no_cursor_timeout, true)
end

投影 (文档 = nil) ⇒ Hash , View

注意：

值为0会从文档中排除字段。 值为1时会将其包含在内。 除_id值外，所有值必须均为0或均为1 。 默认包含_id字段。 必须明确将其排除。

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

例子：

设置要包含或排除的字段。

view.projection(name: 1)

参数：

  • 文档 （哈希） （默认为： nil ） —

    字段和1或0 ，以包含或排除该字段。

返回：

  • （哈希、视图） —

    字段或新的View 。

由于：

  • 2.0.0



466
467
468
469
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第466行

def 投影(文档 = nil)
  validate_doc!(文档) if 文档
  配置(:projection, 文档)
end

# read (value = nil) ⇒符号,视图

注意：

如果未为查询指定任何内容，则将使用集合的读取偏好（read preference）。

用于查询的读取偏好。

参数：

  • 值 （哈希） （默认为： nil ） —

    用于查询的读取偏好模式。

返回：

由于：

  • 2.0.0



482
483
484
485
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第482行

def 读(值 = nil)
  return read_preference if 值.nil?
  配置(:read, 值)
end

# read_concern ⇒对象

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

由于：

  • 2.0.0



631
632
633
634
635
636
637
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第631行

def read_concern
  if 选项[:session] && 选项[:session].in_transaction?
    选项[:session].发送(:txn_read_concern) || 集合.客户端.read_concern
  else
    集合.read_concern
  end
end

# read_preference ⇒对象

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

由于：

  • 2.0.0



640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第640行

def read_preference
  @read_preference ||= 开始
    # 操作读取偏好（read preference）始终受到尊重，并且具有
    # 最高优先级。 如果处于ACID 事务中，我们会查看
    #ACID 事务读取偏好（read preference），默认为客户端，忽略
    #集合读取偏好（read preference）。 如果我们没有处于ACID 事务状态
    # 查看集合读取偏好（read preference），默认为客户端。
    rp = if 选项[:read]
      选项[:read]
    elsif 选项[:session] && 选项[:session].in_transaction?
      选项[:session].txn_read_preference || 集合.客户端.read_preference
    else
      集合.read_preference
    end
    Lint.validate_underscore_read_preference(rp)
    rp
  end
end

# return_key (value = nil) ⇒ true , ...

设置是否仅返回索引字段。

例子：

设置返回键值。

view.return_key(true)

参数：

  • 值 ( true , false ) （默认为： nil ） —

    返回键值。

返回：

  • ( true , false , View ) —

    值或新的View 。

由于：

  • 2.1.0



497
498
499
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第497行

def return_key(值 = nil)
  配置(:return_key, 值)
end

# show_disk_loc (value = nil) ⇒ true , ...也称为： show_record_id

设置是否应显示每个文档的磁盘位置。

例子：

设置显示磁盘位置选项。

view.show_disk_loc(true)

参数：

  • 值 ( true , false ) （默认为： nil ） —

    字段的值。

返回：

  • ( true , false , View ) —

    该值或新的View 。

由于：

  • 2.0.0



512
513
514
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第512行

def show_disk_loc(值 = nil)
  配置(:show_disk_loc, 值)
end

# skip (number = nil) ⇒ Integer , View

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

例子：

设置要跳过的数字。

view.skip(10)

参数：

  • 数字 （整数） （默认为： nil ） —

    要跳过的Docs数量。

返回：

  • ( Integer , View ) —

    跳过值或新的View 。

由于：

  • 2.0.0



528
529
530
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第528行

def 跳过(数字 = nil)
  配置(:skip, 数字)
end

# 快照 (value = nil) ⇒对象

已弃用。

从 MongoDB 服务器版本4.0开始，此选项已弃用。

注意：

设立为 true 时，可防止文档多次返回。

设置视图的快照值。

例子：

设置快照值。

view.snapshot(true)

参数：

  • 值 ( true , false ) （默认为： nil ） —

    快照值。

由于：

  • 2.0.0



546
547
548
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第546行

def snapshot(值 = nil)
  配置(：快照, 值)
end

# sort (spec = nil) ⇒ Hash , View

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

例子：

设置排序条件

view.sort(name: -1)

参数：

  • spec （哈希） （默认为： nil ） —

    排序依据的属性和方向。

返回：

  • （哈希、视图） —

    排序设置或新的View 。

由于：

  • 2.0.0



561
562
563
 
# File ' 构建/ruby-driver-v2.19/lib/ mongo / 集合/view/可读.rb', 第561行

def sort(spec = nil)
  配置(:sort, spec)
end