Clase: Mongo::base de datos

Hereda:
Objeto
  • Objeto
Mostrar todo
Ampliado por:
Reenviable
Incluye:
Reintentar
Definido en:
lib/mongo/database.rb,
lib/mongo/database/view.rb,
lib/mongo/database/cursor_command_view.rb

Overview

Representa una base de datos en el servidor db y las operaciones que se pueden ejecutar en ella a este nivel.

Desde:

  • 2.0.0

Definido bajo Namespace

clase: CursorCommandView, View

Resumen de constantes colapsar

ADMIN =

El nombre de la base de datos admin.

Desde:

  • 2.0.0

'admin'
COMANDO =

La "colección" sobre la que operan los comandos de la base de datos.

Desde:

  • 2.0.0

'$cmd'
DEFAULT_OPTIONS =

Las opciones de base de datos por defecto.

Desde:

  • 2.0.0

opciones::Redactado.Nuevo(database: ADMIN).freeze
NAME =
Obsoleto.

Constante de campo de nombre de base de datos.

Desde:

  • 2.1.0

'Nombre'
base de datos =

Constante de bases de datos.

Desde:

  • 2.1.0

'databases'
namespace =

El nombre de la colección que contiene todos los nombres de las colecciones.

Desde:

  • 2.0.0

'system.namespaces'

Resumen de atributos de la instancia colapsar

Resumen del método de instancia colapsar

Métodos incluidos de Retryable

#read_worker, #select_server, #with_overload_retry, #write_worker

Detalles del Constructor

#initialize(client, name, options = {}) ⇒ Base de datos

Instancie un nuevo objeto de base de datos.

Ejemplos:

Instancia la base de datos.

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

Parámetros:

  • Cliente (Mongo::cliente) —

    El cliente driver.

  • Nombre (String, Símbolo) —

    El nombre de la base de datos.

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

    Las opciones.

Opciones Hash (options):

  • :timeout_ms (Integer) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está definido, lo que significa que se hereda del cliente.

Aumenta:

  • (Mongo::Database::InvalidName) —

    Si el nombre es nil.

Desde:

  • 2.0.0



479
480
481
482
483
484
485
486
487
488
 
# Archivo 'lib/mongo/base de datos.rb', línea 479

def inicializar(Cliente, Nombre, opciones = {})
  propagar Error::InvalidDatabaseName.Nuevo a menos que Nombre
  si Lint.¿habilitado? && !(Nombre.is_a?(String) || Nombre.is_a?(Símbolo))
    propagar "El nombre de la base de datos debe ser un string o un símbolo: #{name}"
  end

  @client = Cliente
  @name = Nombre.to_s.freeze
  @options = opciones.freeze
end

Detalles de atributo de instancias

#cliente ⇒ Cliente (solo lectura)

Devuelve el cliente El cliente de la base de datos.

Devuelve:

  • (cliente) —

    cliente El cliente de la base de datos.

Desde:

  • 2.0.0



61
62
63
 
# Archivo 'lib/mongo/base de datos.rb', línea 61

def Cliente
  @client
end

#nombre ⇒ string (solo lectura)

Devuelve el nombre El nombre de la base de datos.

Devuelve:

  • (string) —

    name El nombre de la base de datos.

Desde:

  • 2.0.0



64
65
66
 
# Archivo 'lib/mongo/base de datos.rb', línea 64

def Nombre
  @name
end

#opciones ⇒ Hash (solo lectura)

Devuelve opciones Las opciones.

Devuelve:

  • (encriptada) —

    opciones Las opciones.

Desde:

  • 2.0.0



67
68
69
 
# Archivo 'lib/mongo/base de datos.rb', línea 67

def opciones
  @options
end

Detalles del método de instancia

#==(otro) ⇒ true, false

Verifique la igualdad del objeto de base de datos con otro. Simplemente comprobará si los nombres son iguales.

Ejemplos:

Verifica la igualdad de la base de datos.

database == other

Parámetros:

  • Otros (objeto) —

    El objeto con el que comparar.

Devuelve:

  • (true, false) —

    Si los objetos son iguales.

Desde:

  • 2.0.0



94
95
96
97
98
 
# Archivo 'lib/mongo/base de datos.rb', línea 94

def ==(Otros)
  return false a menos que Otros.is_a?(Database)

  Nombre == Otros.Nombre
end

#[](collection_name, opciones = {}) ⇒ Mongo::Collection También se conoce como: colección

Obtenga una colección en esta base de datos por el nombre proporcionado.

Ejemplos:

Obtén una colección.

database[:users]

Parámetros:

  • nombre_colección (String, Símbolo) —

    El nombre de la colección.

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

    Las opciones para la colección.

Devuelve:

Desde:

  • 2.0.0



111
112
113
114
115
116
117
118
 
# Archivo 'lib/mongo/base de datos.rb', línea 111

def [](nombre_colección, opciones = {})
  si opciones[API del servidor]
    propagar ArgumentError,
          'La opción :server_api no puede ser especificada para los objetos colección. Solo puede ser especificada a nivel de Cliente'
  end

  Colección.Nuevo(sí mismo, nombre_colección, opciones)
end

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

Realiza una agregación en la base de datos.

Ejemplos:

Realizar una agregación.

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

Parámetros:

  • pipeline (arreglo<Hash>) —

    La pipeline de agregación.

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

    Las opciones de agregación.

Opciones Hash (options):

  • permite_uso_de_disco (verdadero, falso) —

    Establece en "true" si se permite el uso del disco durante la agregación.

  • :batch_size (Integer) —

    El número de documentos a devolver por agrupar.

  • :evitar_validación_del_documento (verdadero, falso) —

    Decidir si omitir o no la validación a nivel de documento.

  • intercalación (encriptada) —

    La intercalación para usar.

  • :comment (objeto) —

    Un comentario proporcionado por el usuario para adjuntar a este comando.

  • max_time_ms (Integer) —

    La cantidad máxima de tiempo permitida para que se ejecute la query, en milisegundos. Esta opción está obsoleta, utiliza :timeout_ms en su lugar.

  • :timeout_ms (Integer) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está establecido, lo que significa que el valor se hereda de la base de datos o del cliente.

  • :hint (string) —

    El índice que se utilizará para la agregación.

  • :: sesión (Sesión) —

    La sesión para usar.

Devuelve:

Desde:

  • 2.10.0



568
569
570
 
# Archivo 'lib/mongo/base de datos.rb', línea 568

def Agregar(pipeline, opciones = {})
  vista.Nuevo(sí mismo, opciones).Agregar(pipeline, opciones)
end

#cluster ⇒ Mongo::Server

Devuelve Obten el servidor primario del clúster.

Devuelve:

Desde:

  • 2.0.0



80
81
 
# Archivo 'lib/mongo/base de datos.rb', línea 80

def_delegators clúster,
Siguiente

#collection_names(opciones = {}) ⇒ arreglo<String>

Nota:

El conjunto de nombres de colecciones devueltos depende de la versión del servidor MongoDB que cumpla con la solicitud.

Obtener todos los nombres de las colecciones no del sistema en la base de datos.

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

Parámetros:

  • opciones (encriptada) (por defecto a: {})

Opciones Hash (options):

  • filtro (encriptada) —

    Un filtro para las colecciones devueltas.

  • :authorized_collections (verdadero, falso) —

    Un indicador, cuando está activado y se usa con nameOnly: true, que permite que un usuario sin el privilegio requerido ejecute el comando cuando se implementa el control de acceso.

  • :comment (objeto) —

    Un comentario proporcionado por el usuario para adjuntar a este comando.

  • :timeout_ms (Integer) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está establecido, lo que significa que el valor se hereda de la base de datos o del cliente.

Devuelve:

  • (arreglo<String>) —

    Nombres de las colecciones.

Desde:

  • 2.0.0



145
146
147
 
# Archivo 'lib/mongo/base de datos.rb', línea 145

def collection_names(opciones = {})
  vista.Nuevo(sí mismo, opciones).collection_names(opciones)
end

#colecciones(opciones = {}) ⇒ Arreglo<Mongo::Colección>

Nota:

El conjunto de colecciones devueltas depende de la versión del servidor MongoDB que satisface la solicitud.

Obtén todas las colecciones no del sistema que pertenecen a esta base de datos.

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

Parámetros:

  • opciones (encriptada) (por defecto a: {})

Opciones Hash (options):

  • filtro (encriptada) —

    Un filtro para las colecciones devueltas.

  • :authorized_collections (verdadero, falso) —

    Una bandera que, cuando se establece como verdadera y se utiliza con name_only: true, permite a un usuario sin el privilegio requerido ejecutar el comando cuando se hace cumplir el control de acceso.

  • :comment (objeto) —

    Un comentario proporcionado por el usuario para adjuntar a este comando.

  • :timeout_ms (Integer) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está establecido, lo que significa que el valor se hereda de la base de datos o del cliente.

Devuelve:

Desde:

  • 2.0.0



206
207
208
 
# Archivo 'lib/mongo/base de datos.rb', línea 206

def collections(opciones = {})
  collection_names(opciones).map { |Nombre| Colección(Nombre) }
end

#command(operación, opts = {}) ⇒ Mongo::Operation::Result

Ejecutar un comando en la base de datos.

Ejemplos:

Ejecute un comando.

database.command(:hello => 1)

Parámetros:

  • Operación (encriptada) —

    El comando a ejecutar.

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

    Las opciones de comando.

  • opciones (encriptada) —

    un conjunto personalizable de opciones

Opciones Hash (opts):

  • :leer (encriptada) —

    La preferencia de lectura para este comando.

  • :: sesión (Sesión) —

    La sesión para utilizar con este comando.

  • execution_options (encriptada) —

    Opciones para pasar al código que ejecuta este comando. Esta es una opción interna y está sujeta a cambios.

    • :deserialize_as_bson [Booleano] Si se debe deserializar la respuesta a este comando utilizando BSON types en lugar de los tipos nativos de Ruby siempre que sea posible.

Devuelve:

Desde:

  • 2.0.0



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
 
# Archivo 'lib/mongo/base de datos.rb', línea 232

def Comando(Operación, opciones = {})
  opciones = opciones.dup
  execution_opts = opciones.borrar(execution_options) || {}

  txn_read_pref = (opciones[:: sesión].preferencia_de_lectura_txn si opciones[:: sesión] && opciones[:: sesión].en_transacción?)
  txn_read_pref ||= opciones[:leer] || ServerSelector::Primario
  Lint.validate_underscore_read_preference(txn_read_pref)
  selector = ServerSelector.Obtener(txn_read_pref)

  Cliente.con_sesión(opciones) hacer |sesión|
    context = Operación::Context.Nuevo(
      cliente: Cliente,
      sesión: sesión,
      operation_timeouts: operation_timeouts(opciones)
    )
    op = Operación::Comando.Nuevo(
      selector: Operación,
      db_name: Nombre,
      leer: selector,
      sesión: sesión
    )

    retry_enabled = Cliente.opciones[:retry_reads] != false &&
                    Cliente.opciones[retry_writes] != false
    con_reintento_por_sobrecarga(context: context, retry_enabled: retry_enabled) hacer
      Server = selector.select_server(clúster, nulo, sesión)
      op.ejecutar(Server, context: context, opciones: execution_opts)
    end
  end
end

#cursor_command(command, options = {}) ⇒ Mongo::Cursor

Ejecute un comando que devuelva un cursor y analice la respuesta como un cursor.

El comando se envía al servidor sin modificar; el driver NO DEBE inspeccionarlo ni alterarlo. Si la respuesta no contiene un campo de cursor, se genera un error. El comando nunca se reintenta.

Nota: si ya se ha establecido un campo maxTimeMS en el documento de comando, se deja tal cual. La opción max_time_ms a continuación solo se aplica a los comandos getMore. No se admite la configuración de timeout_ms y max_time_ms y tiene un comportamiento indefinido.

Ejemplos:

Ejecute un comando que devuelva el cursor.

database.cursor_command(checkMetadataConsistency: 1)

Parámetros:

  • Comando (encriptada) —

    El comando a ejecutar.

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

    Las opciones de comando.

Opciones Hash (options):

  • :leer (encriptada) —

    La preferencia de lectura para este comando, utilizada para la selección del servidor y reutilizada para getMores posteriores.

  • :: sesión (Sesión) —

    La sesión a utilizar. Si no se proporciona ninguna, se crea una sesión implícita y se reutiliza durante la vida útil del cursor.

  • :timeout_ms (Integer) —

    El tiempo de espera de la operación en milisegundos.

  • :batch_size (Integer) —

    El tamaño del lote que se enviará en los comandos getMore.

  • max_time_ms (Integer) —

    El maxTimeMS para enviar en los comandos getMore.

  • :comment (objeto) —

    Un comentario para adjuntar a los comandos getMore.

  • tipo_de_cursor (Símbolo) —

    El tipo de cursor, :tailable o :tailable_await. Debe coincidir con las banderas establecidas en el documento de comando.

  • :timeout_mode (Símbolo) —

    :cursor_lifetime o :iteration.

Devuelve:

  • (Mongo::Cursor) —

    Un cursor sobre los resultados del comando.

Aumenta:

Desde:

  • 2.0.0



301
302
303
304
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
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
 
# Archivo 'lib/mongo/base de datos.rb', línea 301

def cursor_command(Comando, opciones = {})
  opciones = opciones.dup
  execution_opts = opciones.borrar(execution_options) || {}
  view_options = extract_cursor_command_view_options(opciones)

  txn_read_pref = (opciones[:: sesión].preferencia_de_lectura_txn si opciones[:: sesión] && opciones[:: sesión].en_transacción?)
  txn_read_pref ||= opciones[:leer] || ServerSelector::Primario
  Lint.validate_underscore_read_preference(txn_read_pref)
  selector = ServerSelector.Obtener(txn_read_pref)

  # La sesión no está intencionalmente envuelta en #with_session: un implícito
  # la sesión debe sobrevivir a este método y el cursor la finaliza cuando está
  # agotado o cerrado. Hasta que el cursor tome posesión, la sesión y
  # cualquier conexión con equilibrio de carga se limpia aquí en cada ruta de salida.
  sesión = Cliente.get_session(opciones)
  context = Operación::Context.Nuevo(
    cliente: Cliente,
    sesión: sesión,
    operation_timeouts: operation_timeouts(opciones)
  )
  op = Operación::CursorCommand.Nuevo(
    selector: Comando,
    db_name: Nombre,
    leer: selector,
    sesión: sesión
  )

  # Según la especificación de contrapresión del cliente, reintentar un comando genérico en
  # los errores de sobrecarga requieren que tanto las lecturas como los guardados reintentables sean
  # habilitado, igual que el comando de base de datos.
  retry_enabled = Cliente.opciones[:retry_reads] != false &&
                  Cliente.opciones[retry_writes] != false

  Server = nulo
  Conexión = nulo
  cursor = nulo
  begin
    Resultado = con_reintento_por_sobrecarga(context: context, retry_enabled: retry_enabled) hacer
      Server = selector.select_server(clúster, nulo, sesión)
      si Server.load_balancer?
        # El cursor comprueba la conexión cuando se agota.
        Conexión = check_out_cursor_command_connection(Server, context)
        begin
          op.execute_with_connection(Conexión, context: context, opciones: execution_opts)
        rescate StandardError
          # Libere la conexión antes de que el error se propague para que
          # un intento reintentado comprueba uno nuevo.
          Conexión.connection_pool.registrar(Conexión) a menos que Conexión.¿fijado?
          Conexión = nulo
          propagar
        end
      else
        op.ejecutar(Server, context: context, opciones: execution_opts)
      end
    end

    a menos que Resultado.cursor?
      propagar Error::InvalidCursorOperation,
            'La respuesta del comando no incluyó un cursor. ' \
            'Utilice el comando de base de datos para los comandos que no devuelven un cursor.'
    end

    view = CursorCommandView.new(self, view_options)
    cursor = Cursor.new(view, result, servidor, session: session, context: context)
  ensure
    # Si se creó el cursor, es propietario de la sesión y la conexión;
    # de lo contrario (error o ningún cursor en la respuesta) libérelos aquí.
    unless cursor
      connection.connection_pool.check_in(connection) if connection && !connection.pinned?
      session.end_session if session && session.implicit?
    end
  end
  cursor
end

#descartar(opciones = {}) ⇒ Result

Descartar la base de datos y toda la información asociada a ella.

Ejemplos:

Descartar la base de datos.

database.drop

Parámetros:

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

    Las opciones para la operación.

Opciones Hash (options):

  • :: sesión (Sesión) —

    La sesión a utilizar para la operación.

  • conformidad_de_lectura (encriptada) —

    Las opciones de nivel de confirmación de escritura (write concern).

  • :timeout_ms (Integer) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está establecido, lo que significa que el valor se hereda de la base de datos o del cliente.

Devuelve:

  • (Result) —

    El resultado del comando.

Desde:

  • 2.0.0



439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
 
# Archivo 'lib/mongo/base de datos.rb', línea 439

def descartar(opciones = {})
  Operación = { dropDatabase: 1 }
  Cliente.con_sesión(opciones) hacer |sesión|
    write_concern = si opciones[conformidad_de_lectura]
                      Nivel de confirmación de escritura (write concern).Obtener(opciones[conformidad_de_lectura])
                    else
                      sí mismo.write_concern
                    end
    Operación::DropDatabase.Nuevo({
                                  selector: Operación,
                                  db_name: Nombre,
                                  write_concern: write_concern,
                                  sesión: sesión
                                }).ejecutar(
                                  siguiente_principal(nulo, sesión),
                                  context: Operación::Context.Nuevo(
                                    cliente: Cliente,
                                    sesión: sesión,
                                    operation_timeouts: operation_timeouts(opciones)
                                  )
                                )
  end
end

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

Obtén el "sistema de archivos" Grid para esta base de datos.

Parámetros:

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

    Las opciones de GridFS.

Opciones Hash (options):

  • :bucket_name (string) —

    El prefijo para las colecciones de archivos y fragmentos.

  • Tamaño del fragmento (Integer) —

    Anular el tamaño de fragmento por defecto.

  • :fs_name (string) —

    El prefijo para las colecciones de archivos y fragmentos.

  • :leer (string) —

    La preferencia de lectura.

  • :: sesión (Sesión) —

    La sesión para usar.

  • guardar (encriptada) —

    Obsoleto. Equivalente a la opción :write_concern.

  • conformidad_de_lectura (encriptada) —

    Las opciones de nivel de confirmación de escritura (write concern). Puede ser :w => Integer | String, :fsync => booleano, :j => booleano.

Devuelve:

Desde:

  • 2.0.0



522
523
524
 
# Archivo 'lib/mongo/base de datos.rb', línea 522

def fs(opciones = {})
  Cuadrícula::FSBucket.Nuevo(sí mismo, opciones)
end

#inspect ⇒ String

Obtener una inspección de string impresa bonita para la base de datos.

Ejemplos:

Inspecciona la base de datos.

database.inspect

Devuelve:

  • (string) —

    La inspección de la base de datos.

Desde:

  • 2.0.0



498
499
500
 
# Archivo 'lib/mongo/base de datos.rb', línea 498

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

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

Nota:

El conjunto de colecciones devueltas y el esquema del hash de información por colección dependen de la versión del servidor de MongoDB que atienda la solicitud.

Obtenga información sobre todas las colecciones que no son del sistema en la base de datos.

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

Parámetros:

  • opciones (encriptada) (por defecto a: {})

Opciones Hash (options):

  • filtro (encriptada) —

    Un filtro para las colecciones devueltas.

  • Solo :name (verdadero, falso) —

    Indica si el comando debe devolver solo los nombres y el tipo de colección/vista o si debe devolver tanto el nombre como otra información

  • :authorized_collections (verdadero, falso) —

    Un indicador, que al establecerse en verdadero y usarse con nameOnly: true, permite que un usuario sin el privilegio requerido ejecute el comando cuando se aplique el control de acceso.

  • :comment (objeto) —

    Un comentario proporcionado por el usuario para adjuntar a este comando.

  • :timeout_ms (Integer) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está establecido, lo que significa que el valor se hereda de la base de datos o del cliente.

Devuelve:

  • (arreglo<Hash>) —

    Arreglo de hashes de información, uno por cada colección en la base de datos.

Desde:

  • 2.0.5



178
179
180
 
# Archivo 'lib/mongo/base de datos.rb', línea 178

def list_collections(opciones = {})
  vista.Nuevo(sí mismo, opciones).list_collections(opciones)
end

#operation_timeouts(opts) ⇒ Hash

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve el valor de timeout_ms establecido a nivel de la operación (si lo hay), y/o timeout_ms que se establece a nivel de colección/base de datos/cliente (si lo hay).

Devuelve:

  • (encriptada) —

    valor timeout_ms establecido a nivel de operación (si lo hay) y/o timeout_ms establecido a nivel de colección/base de datos/cliente (si lo hay).

Desde:

  • 2.0.0



659
660
661
662
663
664
665
666
667
668
 
# Archivo 'lib/mongo/base de datos.rb', línea 659

def operation_timeouts(opciones)
  # TODO: Deberíamos volver a evaluar si necesitamos dos tiempos de espera por separado.
  {}.tocar hacer |Resultado|
    si opciones[:timeout_ms].nil?
      Resultado[timeout_inherente_ms] = timeout_ms
    else
      Resultado[:operation_timeout_ms] = opciones.borrar(:timeout_ms)
    end
  end
end

#read_command(operación, opts = {}) ⇒ Hash

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Ejecute un comando de lectura en la base de datos, retrying la lectura si es necesario.

Parámetros:

  • Operación (encriptada) —

    El comando a ejecutar.

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

    Las opciones de comando.

Opciones Hash (opts):

  • :leer (encriptada) —

    La preferencia de lectura para este comando.

  • :: sesión (Sesión) —

    La sesión para utilizar con este comando.

  • :comment (objeto) —

    Un comentario proporcionado por el usuario para adjuntar a este comando.

  • :timeout_ms (Integer) —

    El tiempo de espera de la operación en milisegundos. Debe ser un número entero no negativo. Un valor explícito de 0 significa infinito. El valor por defecto no está establecido, lo que significa que el valor se hereda de la base de datos o del cliente.

  • :op_name (String | nil) —

    El nombre de la operación con fines de seguimiento.

Devuelve:

  • (encriptada) —

    El resultado de la ejecución del comando.

Desde:

  • 2.0.0



394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
 
# Archivo 'lib/mongo/base de datos.rb', línea 394

def read_command(Operación, opciones = {})
  txn_read_pref = (opciones[:: sesión].preferencia_de_lectura_txn si opciones[:: sesión] && opciones[:: sesión].en_transacción?)
  txn_read_pref ||= opciones[:leer] || ServerSelector::Primario
  Lint.validate_underscore_read_preference(txn_read_pref)
  preferencia = ServerSelector.Obtener(txn_read_pref)

  Cliente.con_sesión(opciones) hacer |sesión|
    context = Operación::Context.Nuevo(
      cliente: Cliente,
      sesión: sesión,
      operation_timeouts: operation_timeouts(opciones)
    )
    Operación = Operación::Comando.Nuevo(
      selector: Operación.dup,
      db_name: Nombre,
      leer: preferencia,
      sesión: sesión,
      comment: opciones[:comment]
    )
    op_name = opciones[:op_name] || 'Comando'
    trazador.trace_operation(Operación, context, op_name: op_name) hacer
      read_with_retry(sesión, preferencia, context) hacer |Server|
        Operación.ejecutar(Server, context: context)
      end
    end
  end
end

#timeout_ms ⇒ Integer | nil

Este método es parte de una API privada. Se debe evitar el uso de este método si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve Operation timeout que es para esta base de datos o para el cliente correspondiente.

Devuelve:

  • (Integer | nil) —

    Tiempo de espera de la operación que es para esta base de datos o para el cliente correspondiente.

Desde:

  • 2.0.0



651
652
653
 
# Archivo 'lib/mongo/base de datos.rb', línea 651

def timeout_ms
  opciones[:timeout_ms] || Cliente.timeout_ms
end

#usuarios ⇒ Vista::Usuario

Obtener la vista de usuario para esta base de datos.

Ejemplos:

Obtén la vista del usuario.

database.users

Devuelve:

  • (Vista::Usuario) -

    La vista del usuario.

Desde:

  • 2.0.0



534
535
536
 
# Archivo 'lib/mongo/base de datos.rb', línea 534

def Usuarios
  Autenticación::Usuario::vista.Nuevo(sí mismo)
end

#observar(pipeline = [], options = {}) ⇒ ChangeStream

Nota:

Un flujo de cambios solo permite un nivel de consistencia de lectura "mayoría".

Nota:

Este método asistente es preferible a ejecutar una agregación sin procesar con una etapa de $changeStream, con el fin de soportar la capacidad de reanudación.

Permite a los usuarios solicitar que se envíen notificaciones por todos los cambios que ocurran en la base de datos del cliente.

Ejemplos:

Obtén notificaciones de cambios para una determinada base de datos.

database.watch([{ '$match' => { operationType: { '$in' => ['insert', 'replace'] } } }])

Parámetros:

  • pipeline (arreglo<Hash>) (valor por defecto: []) —

    Operadores opcionales de filtro adicional.

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

    Las opciones de flujo de cambios.

Opciones Hash (options):

  • documento_completo (string) —

    Valores permitidos: nil, 'por defecto', 'updateLookup', 'cuando esté disponible', 'requerido'.

    El valor por defecto es no enviar un valor (es decir, nil), el cual es equivalente a 'por defecto'. Por defecto, la notificación de cambio para actualizaciones parciales incluirá un delta que describa los cambios en el documento.

    Cuando se establece en 'updateLookup', la notificación de cambio para actualizaciones parciales incluirá tanto un delta que describe los cambios en el documento como una copia de todo el documento que se modificó en algún momento después de que se haya producido el cambio.

    Cuando se configura en "cuando esté disponible", configura el flujo de cambios para devolver la post-imagen del documento modificado para eventos de cambio de reemplazo y actualización si la post-imagen para este evento está disponible.

    Cuando se establece en 'obligatorio', el comportamiento es el mismo que el de 'whenAvailable', excepto que se produce un error si la imagen de publicación no está disponible.

  • documento_completo_antes_de_modificar (string) —

    Valores permitidos: nil, 'whenAvailable', 'required', 'off'.

    El valor por defecto es no enviar un valor (es decir, nil), que es equivalente a 'apagado'.

    Cuando se establece en 'whenAvailable', configura el flujo de cambios para devolver la preimagen del documento modificado para los eventos de cambio de reemplazo, actualización y eliminación si está disponible.

    Cuando se establece en 'requerido', el mismo comportamiento que "whenAvailable" excepto que se genera un error si la preimagen no está disponible.

  • :resume_after (BSON::Document, Hash) —

    Especifica el punto de partida lógico para el nuevo flujo de cambios.

  • ; tiempo_máximo_espera_ms (Integer) —

    El tiempo máximo que el servidor espera documentos nuevos para satisfacer una query de flujo de cambios.

  • :batch_size (Integer) —

    El número de documentos a devolver por agrupar.

  • intercalación (BSON::Document, Hash) —

    La intercalación para usar.

  • :: sesión (Sesión) —

    La sesión para usar.

  • :start_at_operation_time (BSON::Timestamp) —

    Solo devuelve los cambios que ocurrieron después de la marca de tiempo especificada. Cualquier comando ejecutado contra el servidor devolverá un tiempo de clúster que se puede usar aquí.

  • :comment (objeto) —

    Un comentario proporcionado por el usuario para adjuntar a este comando.

  • Show expanded events (booleano) —

    Permite que el servidor envíe la lista 'ampliada' de eventos de flujo de cambios. La lista de eventos adicionales incluidos con este conjunto de flags son: createIndexes, dropIndexes, modify, create, shardCollection, reshardCollection, refineCollectionShardKey.

Devuelve:

  • (ChangeStream) —

    El objeto de flujo de cambios.

Desde:

  • 2.6.0



635
636
637
638
639
640
641
642
643
644
645
 
# Archivo 'lib/mongo/base de datos.rb', línea 635

def reloj(pipeline = [], opciones = {})
  view_options = opciones.dup
  view_options[tipo_de_cursor] = tailable_await si opciones[; tiempo_máximo_espera_ms]

  mongo::Colección::vista::ChangeStream.Nuevo(
    mongo::Colección::vista.Nuevo(Colección("#{COMMAND}.aggregate"), {}, view_options),
    pipeline,
    mongo::Colección::vista::ChangeStream::DATABASE,
    opciones
  )
end