Módulo: Mongoid::Tasks::base de datos

Ampliado por:
Database
Incluido en:
Database
Definido en:
lib/mongoid/tasks/database.rb

Overview

Módulo de utilidades para gestionar colecciones de base de datos, índices, particionado, etc. Se invoca desde tareas de Rake.

Resumen del método de instancia colapsar

Detalles del método de instancia

#create_collections(models = ::Mongoid.models, force: false) ⇒ Objeto

Cree colecciones para cada modelo dadas las plantillas proporcionadas y que la clase no esté incrustada.

Parámetros:

  • models. (arreglo<Mongoid::Document>) —

    Arreglo de clases de documentos para las que deberían crearse colecciones. Se ha aplicado por defecto a todas las clases de documentos en la aplicación.

  • fuerza (true | false) (por defecto: false) —

    Si es verdadero, el método descartará las colecciones existentes antes de crear nuevas. Si es falso, el método solo creará una nueva colección (que no existe en la base de datos).



19
20
21
22
23
24
25
26
27
28
29
30
31
 
# Archivo 'lib/mongoid/tasks/database.rb', línea 19

def crear_colecciones(modelos = ::Mongoid.modelos, fuerza: false)
  modelos.cada hacer |Modelo|
    si !Modelo.¿Incorporado? || Modelo.¿cíclico?
      Modelo.create_collection(fuerza: fuerza)
      logger.información("MONGOID: Se creó la colección para #{modelo}:")
    else
      logger.información("MONGOID: opciones de colección ignoradas en: #{modelo}, por favor define en el modelo raíz.")
    end
  rescate Excepción
    logger.Error "error al crear la colección para #{modelo}"
    propagar
  end
end

#create_indexes(models = ::Mongoid.models) ⇒ arreglo<Class>

Crear índices para cada modelo dado los globs proporcionados y la clase no está embebida.

Ejemplos:

Crea todos los índices.

Mongoid::Tasks::Database.create_indexes

Devuelve:

  • (arreglo<Class>) —

    Los modelos indexados.



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# Archivo 'lib/mongoid/tasks/database.rb', línea 40

def create_indexes(modelos = ::Mongoid.modelos)
  modelos.cada hacer |Modelo|
    Next si Modelo.especificaciones_del_índice.¿vacío?

    si !Modelo.¿Incorporado? || Modelo.¿cíclico?
      Modelo.create_indexes
      logger.información("MONGOID: Índices creados en #{modelo}:")
      Modelo.especificaciones_del_índice.cada hacer |especificación|
        logger.información("MONGOID: Índice: #{spec.key}, Opciones: #{spec.options}")
      end
      Modelo
    else
      logger.información("MONGOID: Índice ignorado en: #{modelo}, por favor, define en el modelo raíz.")
      nulo
    end
  end.compact
end

#create_search_indexes(models = ::Mongoid.models, wait: true) ⇒ Objeto

Envía solicitudes para que se creen los índices de búsqueda. Esto ocurrirá de forma asíncrona. Si "wait" es verdadero, el método se bloqueará mientras espera que se creen los índices.

Parámetros:

  • modelos (arreglo<Mongoid::documento>) (valor por defecto: ::Mongoid.models) —

    los modelos para compilar índices de búsqueda.

  • esperar (true | false) (por defecto: true) —

    si se debe esperar a que se compilen los índices.



66
67
68
69
70
71
72
73
74
75
76
 
# Archivo 'lib/mongoid/tasks/database.rb', línea 66

def create_search_indexes(modelos = ::Mongoid.modelos, esperar: true)
  buscable = modelos.Seleccionar { |m| m.search_index_specs.any? }

  # poner en cola las solicitudes de creación de índices de búsqueda
  nombres_de_índices_por_modelo = buscable.each_with_object({}) hacer |Modelo, obj|
    logger.información("MONGOID: Creando índices de búsqueda en #{modelo}...")
    obj[Modelo] = Modelo.create_search_indexes
  end

  wait_for_search_indexes(nombres_de_índices_por_modelo) si esperar
end

#remove_indexes(models = ::Mongoid.models) ⇒ arreglo<Class>

Remueva los índices de cada modelo según los globs proporcionados y la clase no esté integrada.

Ejemplos:

Remover todos los índices.

Mongoid::Tasks::Database.remove_indexes

Devuelve:

  • (arreglo<Class>) —

    Los modelos no indexados.



139
140
141
142
143
144
145
146
147
148
149
150
 
# Archivo 'lib/mongoid/tasks/database.rb', línea 139

def remove_indexes(modelos = ::Mongoid.modelos)
  modelos.cada hacer |Modelo|
    Next si Modelo.¿Incorporado?

    begin
      Modelo.remove_indexes
    rescate mongo::Error::OperationFailure
      Next
    end
    Modelo
  end.compact
end

#remove_search_indexes(models = ::Mongoid.models) ⇒ objeto

Remueve todos los índices de búsqueda de los modelos proporcionados.



156
157
158
159
160
161
162
 
# Archivo 'lib/mongoid/tasks/database.rb', línea 156

def remove_search_indexes(modelos = ::Mongoid.modelos)
  modelos.cada hacer |Modelo|
    Next si Modelo.¿Incorporado?

    Modelo.remove_search_indexes
  end
end

#remove_undefined_indexes(models = ::Mongoid.models) ⇒ Hash{clase => arreglo(Hash)}

Remueva los índices que existen en la base de datos pero no están especificados en los models.

Ejemplos:

Remueve los índices indefinidos.

Mongoid::Tasks::Database.remove_undefined_indexes

Devuelve:

  • (Hash{clase => arreglo(Hash)}) —

    La lista de índices que fueron eliminados por el modelo.



118
119
120
121
122
123
124
125
126
127
128
129
130
 
# Archivo 'lib/mongoid/tasks/database.rb', línea 118

def eliminar_índices_indefinidos(modelos = ::Mongoid.modelos)
  undefined_indexes(modelos).cada hacer |Modelo, indexes|
    indexes.cada hacer |index|
      llave = index['key'].symbolize_keys
      Colección = Modelo.Colección
      Colección.indexes(sesión: Modelo.enviar(:_session)).drop_one(llave)
      logger.información(
        "MONGOID: Se eliminó el índice '#{índice['nombre']}' en la colección " +
        "'#{colección.nombre}' en la base de datos '#{colección.base de datos.nombre}'."
      )
    end
  end
end

#shard_collections(models = ::Mongoid.models) ⇒ arreglo<Class>

Colecciones de particiones para modelos que declaran claves de partición.

Devuelve las clases de modelo que han tenido sus colecciones fragmentadas, incluyendo clases de modelo cuyas colecciones ya habían sido fragmentadas antes de la invocación de este método.

Ejemplos:

Fragmenta todas las colecciones

Mongoid::Tasks::Database.shard_collections

Devuelve:

  • (arreglo<Class>) —

    Los modelos particionado



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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# Archivo 'lib/mongoid/tasks/database.rb', línea 174

def colecciones de shards(modelos = ::Mongoid.modelos)
  modelos.map hacer |Modelo|
    Next si Modelo.shard_config.nil?

    si Modelo.¿Incorporado? && !Modelo.¿cíclico?
      logger.advertencia("MONGOID: #{modelo} tiene configuración de partición pero está embebido")
      Next
    end

    a menos que Modelo.Colección.clúster.particionado? || Modelo.Colección.clúster.balanceo_de_carga?
      logger.advertencia("MONGOID: #{model} tiene configuración de partición pero no está guardada en un clúster: #{model.colección.cluster.summary}")
      Next
    end

    La base de datos de la colección debe existir para ejecutar collStats.
    # Dependiendo de la versión del servidor, la propia colección también debe
    # existir.
    # MongoDB no tiene un comando para crear la base de datos; lo mejor
    # aproximación a ello es crear la colección que queremos.
    # En los servidores más antiguos, crear una colección que ya exista es
    # un error.
    # Además, 3.6 y potencialmente servidores más antiguos no proporcionan
    # el código de error cuando se les pide computar estadísticas de colección a un elemento inexistente
    # colección (https://jira.mongodb.org/browse/SERVER-50070).
    begin
      Modelo.Colección.database.Comando(collStats: Modelo.Colección.Nombre).primero
    rescate mongo::Error::OperationFailure => e
      # El código 26 es que la base de datos no existe.
      # El código 8 es una colección que no existe, desde 4.0.
      # En 3.6 y versiones anteriores, iguala el texto del mensaje de excepción.
      si e.Código == 26 || e.Código == 8 ||
         (e.Código.nil? && e.mensaje =~ /no encontrado/)
        Modelo.Colección.Cree

        Modelo.Colección.database.Comando(collStats: Modelo.Colección.Nombre).primero
      else
        propagar
      end
    end

    stats = Modelo.Colección.database.Comando(collStats: Modelo.Colección.Nombre).primero
    si stats[particionado]
      logger.información("MONGOID: #{modelo.colección.namespace} ya está particionado para #{modelo}")
      Next Modelo
    end

    admin_db = Modelo.Colección.Cliente.Usar(Administrador).database

    begin
      admin_db.Comando(enableSharding: Modelo.Colección.database.Nombre)
    rescate mongo::Error::OperationFailure => e
      # El servidor 2.6 falla si el particionado ya está habilitado
      propagar a menos que e.Código == 23 || (e.Código.nil? && e.mensaje =~ /ya está activado/)
      # Nada
    end

    begin
      admin_db.Comando(shardCollection: Modelo.Colección.namespace, **Modelo.shard_config)
    rescate mongo::Error::OperationFailure => e
      logger.Error("MONGOID: No se pudo fragmentar la colección #{model.collection.namespace} para #{model}: #{e.class}: #{e}")
      Next
    end

    logger.información("MONGOID: colección particionada #{model.colección.namespace} para #{model}")

    Modelo
  end.compact
end

#undefined_indexes(models = ::Mongoid.models) ⇒ Arreglo<Hash>

Devuelve la lista de índices por model que existen en la base de datos, pero no están especificados en los models.

Ejemplos:

Devuelve la lista de índices no utilizados.

Mongoid::Tasks::Database.undefined_indexes

Devuelve:

  • (arreglo<Hash>) —

    La lista de índices indefinidos por modelo.



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# Archivo 'lib/mongoid/tasks/database.rb', línea 85

def undefined_indexes(modelos = ::Mongoid.modelos)
  undefined_by_model = {}

  modelos.cada hacer |Modelo|
    Next si Modelo.¿Incorporado?

    begin
      Modelo.Colección.indexes(sesión: Modelo.enviar(:_session)).cada hacer |index|
        # ignore default index
        Next si index['nombre'] == '_id_'

        llave = index['key'].symbolize_keys
        especificación = Modelo.index_specification(llave, index['nombre'])
        Next si especificación

        # índice no especificado
        undefined_by_model[Modelo] ||= []
        undefined_by_model[Modelo] << index
      end
    rescate mongo::Error::OperationFailure
    end
  end

  undefined_by_model
end