Clase: Mongo::Cursor Privado

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
Enumerable, reintentable
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. Debe evitar usarla siempre que sea posible, ya que podría eliminarse o modificarse 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 su lugar, Collection::View expone la interfaz Enumerable a las aplicaciones, y el enumerador está respaldado por una instancia Cursor.

Ejemplos:

Obtenga una matriz de 5 usuarios llamados Emily.

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

Llamar a un bloque en cada documento de usuario.

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

Subclases conocidas directas

Cursor de almacenamiento en caché

Definido en el espacio de nombres

Modules: No colable Clases: KillSpec

Colapso delresumen de atributos de instancia

Colapso delresumen del método de clase

Colapso del resumen del método de instancia

Métodos incluidos en Retryable

#trabajador_de_lectura, #servidor_de_selección, #trabajador_de_escritura

Detalles del constructor

#inicializar(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 (Operación::Resultado) —

    El resultado de la primera ejecución.

  • Server (Servidor) —

    El servidor al que está bloqueado este cursor.

  • opciones (Hash) (predeterminado: {}) —

    Las opciones del cursor.

Opciones Hash(opciones):

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

    El contexto de operación para este cursor.

  • :deshabilitar_reintentar (verdadero,falso) —

    Si se debe deshabilitar la reintención en caso de error al enviar operaciones getMore (obsoleto, las operaciones getMore ya no se vuelven a intentar)

  • :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 no ser que resultado.is_a?(Operación::Resultado)
    propagar ArgumentError, "Elsegundo argumento debe ser un Mongo::Operation::Result: #{result.inspect}"
  end

  @view = vista
  @server = Server
  @resultado_inicial = resultado
  @espacio de nombres = 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
  @opciones = opciones
  @sesión = @opciones[:sesión]
  @conexión_global_id = resultado.id_global_de_conexión
  @contexto = @opciones[:context]&.con(id_global_de_conexión: connection_global_id_for_context) || contexto fresco
  @explicitly_closed = false
  @cerrar = Mutex.Nuevo
  Si Server.¿equilibrador de carga?
    # Necesitamos la conexión en el cursor sólo en topología de carga balanceada;
    # De lo contrario no necesitamos una referencia adicional.
    @conexión = @resultado_inicial.conexión
  end
  Si ¿cerrado?
    conexión de registro
  else
    registro
    ObjectSpace.define_finalizador(
      yo,
      yo.clase.finaliza(especificación de muerte(@conexión_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
  @resultado_inicial
end

#resume_token ⇒ BSON::Document | 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 cambio

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

#view ⇒ Collection::View (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.

Vista de retorno La vista de colección.

Devuelve:



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

def vista
  @view
end

Detalles del método de clase

.finalizar(kill_spec, cluster) ⇒ 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.

Finaliza el cursor para la recolección de elementos no utilizados. Programa este cursor para que se incluya en una operación killCursors ejecutada por el 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:

  • (Procedimiento) —

    El finalizador.



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

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

Detalles del método de instancia

#tamaño_del_lote ⇒ Entero

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 tamaño del lote.

Ejemplos:

Obtenga el tamaño del lote.

cursor.batch_size

Devuelve:

  • (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

#cerrar(opciones = {}) ⇒ 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 en el cliente y 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[:tiempo de espera_ms]) : contexto fresco(opta)

  unregister
  lectura_con_un_reintento hacer
    especulación = {
      nombre_coll: nombre_de_colección,
      nombre_base_datos: database.Nombre,
      cursor_ids: [ID.],
    }
    op = Operación::Matar cursores.Nuevo(especulación)
    ejecutar_operación(op, context: ctx)
  end

  nulo
rescate Error::Operación fallida::Familia, Error::Error de socket, Error::Error de tiempo de espera del socket, Error::ServerNotUsable
  # Los errores se absorben porque no se puede hacer nada para manejarlos.
asegurar
  fin_sesión
  @cursor_id = 0
  @cerrar.sincronizar hacer
    @explicitly_closed = true
  end
  conexión de registro
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 nunca debería ser nulo
  @cursor_id.nil? || @cursor_id == 0
end

#nombre_de_colección ⇒ Cadena

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:

  • (Cadena) -

    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_de_colección
  # En la mayoría de los casos, esto 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 @espacio de nombres
    # A menudo, el espacio de nombres tendrá 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 espacio de nombres después del primero.
    componentes ns = @espacio de nombres.división('.')
    componentes ns[1...componentes ns.longitud].Join('.')
  else
    Colección.Nombre
  end
end

#cada ⇒ Enumerador

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

Iterar a través de los documentos devueltos de la consulta.

Un cursor se puede iterar 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

  # Si ya hemos iterado más allá del primer lote (es decir, llamado get_more
  # al menos una vez), el cursor en el lado del servidor ha avanzado más allá
  # el primer lote y reiniciar la iteración desde el principio
  # devolver el resultado inicial no incluiría los documentos del segundo lote
  # y los lotes subsiguientes hasta donde se encuentre el cursor. Detectar esto
  # condición y abortar la iteración.
  #
  # En una futura versión del controlador, cada uno continuaría desde el
  # fin de la iteración anterior o siempre se reiniciará desde el
  # comienzo.
  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 versiones del controlador anteriores a2.10, restablezca
  # la matriz de documentos cada vez que se inicia una nueva iteración.
  @documents = nulo

  Si ¿bloque_dado?
    # StopIteration generado por try_next finaliza este bucle.
    bucle hacer
      Documento = try_next
      Si ¿explícitamente_cerrado?
        propagar Error::OperaciónCursorInválida, 'Elcursor se cerró explícitamente'
      end
      rendimiento Documento Si Documento
    end
    yo
  else
    Documentos = []
    # StopIteration generado por try_next finaliza este bucle.
    bucle hacer
      Documento = try_next
      Si ¿explícitamente_cerrado?
        propagar Error::OperaciónCursorInválida, 'Elcursor 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?
  !!@completamente_iterado
end

#obtener_más ⇒ Matriz<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:

  • (Matriz<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 volver a intentar getMores.
  # Se utilizó lógica de lectura reintentable heredada para volver a intentar obtenerMores, pero desde entonces
  # hacerlo puede dar lugar a una pérdida de datos silenciosa, el controlador ya no intenta de nuevo
  #Obtener más operaciones en cualquier circunstancia.
  # https://github.com/mongodb/specifications/blob/master/source/retryable-reads/retryable-reads.md#qa
  proceso(ejecutar_operación(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:

  • (Entero) —

    El identificador del cursor.

Desde:

  • 2.2.0



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

def ID.
  @cursor_id
end

#inspeccionar ⇒ Cadena

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 una representación de cadena legible por humanos de Cursor.

Ejemplos:

Inspeccione el cursor.

cursor.inspect

Devuelve:

  • (Cadena) -

    Una representación de cadena de una instancia 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(id_global_de_conexión) ⇒ 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(id_global_de_conexión)
  KillSpec.Nuevo(
    cursor_id: ID.,
    nombre_coll: nombre_de_colección,
    nombre_base_datos: database.Nombre,
    id_global_de_conexión: id_global_de_conexión,
    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:

Obtenga el número para regresar.

cursor.to_return

Devuelve:

  • (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 consulta, si hay alguno 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.

Aumentos:

  • (Detener la iteración) —

    Se activa en las llamadas después de que el cursor se haya iterado por completo.



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 tienen una copia del controlador antiguo del cursor
    # código, nuestra llamada dup en #proceso no se invoca cuando se realiza una consulta Mongoid
    # La caché está activa. Para solucionarlo, también llama a dup aquí.
    # el resultado del proceso que podría surgir del código de Mongoid.
    @documents = proceso(@resultado_inicial).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
    token de reanudación de lote de caché

    a no ser que ¿cerrado?
      Si ¿exhausto?
        cerrar
        @completamente_iterado = true
        propagar Detener la iteración
      end
      @documents = obtener más
    else
      @completamente_iterado = true
      propagar Detener la iteración
    end
  else
    # el cursor se cierra aquí
    # mantener los documentos como una matriz vacía
  end

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

  # Almacenar en caché el token de reanudación del lote si estamos iterando
  # sobre el último documento, o si el lote está vacío
  Si @documents.tamaño < = 1
    token de reanudación de lote de caché
    Si ¿cerrado?
      @completamente_iterado = true
    end
  end

  return @documents.cambio
end