Clase: Mongo::Cursor Privado

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
Enumerable, Reintento posible
Definido en:
lib/mongo/cursor.rb,
lib/mongo/cursor/kill_spec.rb,
lib/mongo/cursor/nontailable.rb

Overview

Esta clase forma parte de una API privada. Evita usar esta clase si es posible, ya que puede ser eliminada o modificada en el futuro.

Representación del lado del cliente de un iterador sobre un conjunto de resultados de consulta en el servidor.

Cursor los objetos no se exponen directamente al código de la aplicación. En cambio, Collection::View expone la interfaz Enumerable a las aplicaciones, y el enumerador está respaldado por una instancia de Cursor.

Ejemplos:

Obtenga un arreglo de 5 usuarios llamados Emily.

users.find({:name => 'Emily'}).limit(5).to_a

Ejecuta un bloque en cada documento de usuario.

users.find.each { |doc| puts doc }

Subclases conocidas directas

CachingCursor

Definido bajo Namespace

Modules: No encajable Clases: KillSpec

Resumen de atributos de la instancia colapsar

Resumen del método de clase colapsar

Resumen del método de instancia colapsar

Métodos incluidos en Retryable

#read_worker, #select_server, #write_worker

Detalles del constructor

#initialize(vista, resultado, servidor, opciones = {}) ⇒ Cursor

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Crea un objeto Cursor.

Ejemplos:

Instanciar el cursor.

Mongo::Cursor.new(view, response, server)

Parámetros:

  • vista (CollectionView) —

    El CollectionView que define la consulta.

  • Resultado (Operation::Result) —

    El resultado de la primera ejecución.

  • Server (Servidor) —

    El servidor al que este cursor está bloqueado.

  • opciones (Hash) (por defecto: {}) —

    Las opciones del cursor.

Opciones Hash (options):

  • :context (Operación::Contexto) —

    El contexto de la operación para este cursor.

  • Desactivar Reintentar (verdadero, falso) —

    Si se debe desactivar el reintento en caso de error al enviar operaciones getMore (obsoleto, las operaciones getMore ya no se reintentan)

  • :retry_reads (verdadero, falso) —

    Reintentar lecturas (siguiendo el mecanismo moderno), el valor por defecto es verdadero

Desde:

  • 2.0.0



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# Archivo 'lib/mongo/cursor.rb', línea 74

def inicializar(vista, Resultado, Server, opciones = {})
  a menos que Resultado.is_a?(Operación::Resultado)
    propagar ArgumentError,  "El segundo argumento debe ser un Mongo::Operation::Result: #{resultado.inspectar} "
  end

  @view = vista
  @server = Server
  @initial_result = Resultado
  @namespace = Resultado.namespace
  @remaining = limit si ¿limitado?
  set_cursor_id(Resultado)
  si @cursor_id.nil?
    propagar ArgumentError, 'El id del cursor debe estar presente en el resultado'
  end
  @options = opciones
  @sesión = @options[:: sesión]
  @connection_global_id = Resultado.connection_global_id
  @contexto = @options[:context]&.con(id_global_de_conexión: connection_global_id_for_context) || contexto fresco
  @explicitly_closed = false
  @lock = Mutex (exclusión mutua).Nuevo
  si Server.load_balancer?
    # Necesitamos la conexión en el cursor solo en la topología equilibrada;
    # De lo contrario no necesitamos una referencia adicional.
    @conexión = @initial_result.Conexión
  end
  si ¿Cerrado?
    verificar_conexión
  else
    registrar
    ObjectSpace.define_finalizer(
      sí mismo,
      sí mismo.clase.finaliza(especificación de muerte(@connection_global_id), clúster)
    )
  end
end

Detalles de los atributos de instancia

#conexión ⇒ Objeto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro. 



117
118
119
 
# Archivo 'lib/mongo/cursor.rb', línea 117

def Conexión
  @conexión
end

#contexto ⇒ Operación::Contexto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve el contexto de este cursor.

Devuelve:



53
54
55
 
# Archivo 'lib/mongo/cursor.rb', línea 53

def context
  @contexto
end

#resultado_inicial ⇒ Objeto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro. 



114
115
116
 
# Archivo 'lib/mongo/cursor.rb', línea 114

def resultado inicial
  @initial_result
end

#resume_token ⇒ BSON::documento | nil (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

El token de reanudación rastreado por el cursor para la reanudación del flujo de cambios

Devuelve:

  • (BSON::Document | nil) —

    El token de reanudación del cursor.



50
51
52
 
# Archivo 'lib/mongo/cursor.rb', línea 50

def resume_token
  @resume_token
end

#servidor ⇒ objeto (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro. 



111
112
113
 
# Archivo 'lib/mongo/cursor.rb', línea 111

def Server
  @server
end

#vista ⇒ Colección::Vista (solo lectura)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve vista La vista de la colección.

Devuelve:



44
45
46
 
# Archivo 'lib/mongo/cursor.rb', línea 44

def vista
  @view
end

Detalles del método de clase

.finalize(kill_spec, clúster) ⇒ Proc

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Finalice el cursor para la colección de basura. Programa este cursor para ser incluido en una operación killCursors ejecutada por CursorReaper del clúster.

Parámetros:

  • especificación de muerte (Cursor::KillSpec) —

    La especificación de la operación KillCursor.

  • clúster (Mongo::Cluster) —

    El clúster asociado con este cursor y su servidor.

Devuelve:

  • (Proc) —

    El finalizador.



128
129
130
131
132
133
134
135
 
# Archivo 'lib/mongo/cursor.rb', línea 128

def sí mismo.finaliza(especificación de muerte, clúster)
  a menos que KillSpec === especificación de muerte
    propagar ArgumentError, "Elprimer argumento debe ser un KillSpec: #{kill_spec.inspect}"
  end
  proc hacer
    clúster.schedule_kill_cursor(especificación de muerte)
  end
end

Detalles del método de instancia

#batch_size ⇒ Integer

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Obtén el tamaño del lote.

Ejemplos:

Obtén el tamaño del lote.

cursor.batch_size

Devuelve:

  • (Número entero) —

    El tamaño del lote.

Desde:

  • 2.2.0



279
280
281
282
283
284
285
286
 
# Archivo 'lib/mongo/cursor.rb', línea 279

def tamaño del lote
  Valor = @view.tamaño del lote && @view.tamaño del lote > 0 ? @view.tamaño del lote : limit
  si Valor == 0
    nulo
  else
    Valor
  end
end

#close(opts = {}) ⇒ nil(nulo)

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Cierra este cursor, liberando cualquier recurso asociado tanto en el cliente como en el servidor.

Devuelve:

  • (nil) —

    Siempre nulo.



305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
 
# Archivo 'lib/mongo/cursor.rb', línea 305

def Cerrar(opta = {})
  return si ¿Cerrado?

  ctx = context ? context.actualizar(tiempo_de_espera_ms: opta[:timeout_ms]) : contexto fresco(opta)

  unregister
  read_with_one_retry hacer
    especulación = {
      nombre_coll: nombre_colección,
      nombre_base_datos: database.Nombre,
      cursor_ids: [ID],
    }
    op = Operación::killCursors.Nuevo(especulación)
    execute_operation(op, context: ctx)
  end

  nulo
rescate Error::OperationFailure::Familia, Error::Error de socket, Error::SocketTimeoutError, Error::ServerNotUsable
  # Los errores se descartan ya que no se puede hacer nada para manejarlos.
asegurar
  fin_sesión
  @cursor_id = 0
  @lock.sincronizar hacer
    @explicitly_closed = true
  end
  verificar_conexión
end

#cerrado? ⇒ verdadero, falso

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

¿Está cerrado el cursor?

Ejemplos:

¿Está cerrado el cursor?

cursor.closed?

Devuelve:

  • (verdadero,falso) —

    Si el cursor está cerrado.

Desde:

  • 2.2.0



296
297
298
299
 
# Archivo 'lib/mongo/cursor.rb', línea 296

def ¿Cerrado?
  # @cursor_id en principio no debería ser nunca nil
  @cursor_id.nil? || @cursor_id == 0
end

#collection_name ⇒ String

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Obtenga el nombre de la colección procesada.

Ejemplos:

Obtenga el nombre de la colección procesada.

cursor.coll_name

Devuelve:

  • (string) —

    El nombre de la colección.

Desde:

  • 2.2.0



341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
 
# Archivo 'lib/mongo/cursor.rb', línea 341

def nombre_colección
  # En la mayoría de los casos, será equivalente al nombre de la colección
  # objeto en el controlador. Sin embargo, en algunos casos (por ejemplo, cuando se conecta
  # a un Atlas Data Lake), el namespace devuelto por el comando find
  # puede ser diferente, por eso queremos usar el nombre de colección basado
  # en el espacio de nombres en el resultado del comando.
  si @namespace
    # A menudo, el namespace estará en el formato "database.collection".
    # Sin embargo, a veces el nombre de la colección contendrá puntos, que
    # es por eso que este método une todos los componentes del namespace después del primero.
    componentes ns = @namespace.división('.')
    componentes ns[1...componentes ns.longitud].unirse('.')
  else
    Colección.Nombre
  end
end

#cada uno ⇒ Enumerator

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Itera a través de los documentos devueltos por la query.

Un cursor puede ser iterado como máximo una vez. También se permite la iteración incompleta. Intentar iterar el cursor más de una vez genera InvalidCursorOperation.

Ejemplos:

Iterar sobre los documentos en el cursor.

cursor.each do |doc|
  ...
end

Devuelve:

  • (Enumerator) —

    El enumerador.

Desde:

  • 2.0.0



163
164
165
166
167
168
169
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
200
201
202
203
204
205
 
# Archivo 'lib/mongo/cursor.rb', línea 163

def cada

  # Se já iteramos além do primeiro lote (ou seja, chamamos get_more
  # al menos una vez), el cursor en el lado del servidor ha avanzado más allá
  # el primer agrupar y reiniciar la iteración desde el principio por
  # devolver el resultado inicial no incluiría los documentos del segundo lote
  # y lotes subsiguientes hasta donde esté el cursor. Detecte esto
  # condición y abortar la iteración.
  #
  # En una futura versión del controlador, cada uno continuaría desde el
  # final de la iteración anterior o siempre se reiniciaría desde el
  # principio.
  si @get_more_called
    propagar Error::OperaciónCursorInválida, 'Nose puede reiniciar la iteración de un cursor que emitió un getMore'
  end

  # Para mantener la compatibilidad con las versiones previas a2.10 versiones del driver, restablecer
  # el arreglo de documentos cada vez que se inicia una nueva iteración.
  @documents = nulo

  si ¿block_given?
    # StopIteration generado por try_next termina este ciclo.
    bucle hacer
      Documento = try_next
      si ¿explícitamente_cerrado?
        propagar Error::OperaciónCursorInválida, 'El cursor se cerró explícitamente'
      end
      rendimiento Documento si Documento
    end
    sí mismo
  else
    Documentos = []
    # StopIteration generado por try_next termina este ciclo.
    bucle hacer
      Documento = try_next
      si ¿explícitamente_cerrado?
        propagar Error::OperaciónCursorInválida, 'El cursor se cerró explícitamente'
      end
      Documentos << Documento si Documento
    end
    Documentos
  end
end

#completamente_iterado? ⇒ Booleano

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve:

  • (booleano) 


416
417
418
 
# Archivo 'lib/mongo/cursor.rb', línea 416

def ¿completamente_iterado?
  !!@fully_iterated
end

#get_more ⇒ arreglo<BSON::Document>

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Ejecute un comando getMore y devuelva el lote de documentos obtenidos del servidor.

Devuelve:

  • (arreglo<BSON::Document>) —

    El lote de documentos



391
392
393
394
395
396
397
398
399
400
 
# Archivo 'lib/mongo/cursor.rb', línea 391

def obtener más
  @get_more_called = true

  # La especificación moderna de lecturas reintentables prohíbe reintentar getMores.
  # La antigua lógica de reintentos utilizaba lecturas reintentables para volver a intentar getMores, pero desde
  # hacerlo puede dar lugar a una pérdida de datos silenciosa, el controlador ya no intenta de nuevo
  # operaciones getMore en cualquier circunstancia.
  # https://github.com/mongodb/specifications/blob/master/source/retryable-reads/retryable-reads.md#qa
  Proceso(execute_operation(get_more_operation))
end

#id ⇒ Integer

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Nota:

Un id de cursor de 0 significa que el cursor se cerró en el servidor.

Obtener el id del cursor.

Ejemplos:

Obtener el id del cursor.

cursor.id

Devuelve:

  • (Número entero) —

    El id del cursor.

Desde:

  • 2.2.0



368
369
370
 
# Archivo 'lib/mongo/cursor.rb', línea 368

def ID
  @cursor_id
end

#inspect ⇒ String

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Obtén una representación en string legible por humanos de Cursor.

Ejemplos:

Inspecciona el cursor.

cursor.inspect

Devuelve:

  • (string) —

    Una representación en string de una instancia de Cursor.

Desde:

  • 2.0.0



145
146
147
 
# Archivo 'lib/mongo/cursor.rb', línea 145

def inspeccionar
  "#<Mongo::Cursor:0x#{object_id} @view=#{@view.inspect}>"
end

#kill_spec(connection_global_id) ⇒ Objeto

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro. 



403
404
405
406
407
408
409
410
411
412
413
 
# Archivo 'lib/mongo/cursor.rb', línea 403

def especificación de muerte(connection_global_id)
  KillSpec.Nuevo(
    cursor_id: ID,
    nombre_coll: nombre_colección,
    nombre_base_datos: database.Nombre,
    id_global_de_conexión: connection_global_id,
    dirección del servidor: Server.dirección,
    sesión: @sesión,
    conexión: @conexión
  )
end

#to_return ⇒ Integer

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Obtener el número de documentos a devolver. Se utiliza en 3.0 y versiones anteriores del servidor.

Ejemplos:

Obtén el número a devolver.

cursor.to_return

Devuelve:

  • (Número entero) —

    El número de documentos a devolver.

Desde:

  • 2.2.0



381
382
383
 
# Archivo 'lib/mongo/cursor.rb', línea 381

def to_return
  use_limit? ? @remaining : (tamaño del lote || 0)
end

#try_next ⇒ BSON::Document | nil

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Nota:

Este método es experimental y está sujeto a cambios.

Devuelve un documento de la query, si hay uno disponible.

Este método esperará hasta max_await_time_ms milisegundos para recibir cambios del servidor y, si no se reciben, devolverá nulo. Si no hay más documentos que devolver del servidor o si se ha agotado el cursor, se generará una excepción StopIteration.

Devuelve:

  • (BSON::Document | nil) —

    Un documento.

Aumenta:

  • (Detener la iteración) —

    Se activó en las llamadas después de que el cursor se había iterado completamente.



223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# Archivo 'lib/mongo/cursor.rb', línea 223

def try_next
  si @documents.nil?
    # Dado que las versiones publicadas de Mongoid contienen una copia del cursor de driver antiguo
    # código, nuestra llamada dup en #process no se invoca cuando hay una query de Mongoid
    # La caché está activa. Soluciona eso llamando también a dup aquí en
    # el resultado de #proceso que podría derivarse del código de Mongoid.
    @documents = Proceso(@initial_result).dup
    # los documentos aquí pueden ser una matriz vacía, por lo tanto
    # podemos terminar emitiendo un getMore en la primera llamada try_next
  end

  si @documents.¿vacío?
    # En lotes vacíos, almacenamos en caché el token de reanudación del lote
    cache_batch_resume_token

    a menos que ¿Cerrado?
      si ¿agotado?
        Cerrar
        @fully_iterated = true
        propagar Detener la iteración
      end
      @documents = obtener más
    else
      @fully_iterated = true
      propagar Detener la iteración
    end
  else
    # el cursor se cierra aquí
    # mantener los documentos como un arreglo vacío
  end

  # Si hay al menos un documento, almacenar en caché su _id
  si @documents[0]
    cache_resume_token(@documents[0])
  end

  # Guarda en caché el token de reanudación por lotes si estamos iterando
  # sobre el último documento, o si el lote está vacío
  si @documents.tamaño <= 1
    cache_batch_resume_token
    si ¿Cerrado?
      @fully_iterated = true
    end
  end

  return @documents.turno
end