Módulo: Mongoid::Tareas::Base de datos

Ampliado por:
Database
Incluido en:
Database
Definido en:
lib/mongoid/tareas/base de datos.rb

Overview

Módulo de utilidad para administrar colecciones de bases de datos, índices, fragmentación, etc. Se invoca desde tareas de Rake.

Colapso del resumen del método de instancia

Detalles del método de instancia

# crear_colecciones(modelos =::Mongoid.models, fuerza: falso)⇒ Objeto

Crea colecciones para cada modelo dados los globs proporcionados y la clase no está incorporada.

Parámetros:

  • modelos. (Matriz) —

    Matriz de clases de documentos para las que se deben crear colecciones. El valor predeterminado son todas las clases de documentos de la aplicación.

  • fuerza (true | false) (predeterminado: falso)

    Si es verdadero, el método eliminará las colecciones existentes antes de crear nuevas. Si es falso, el método solo creará colecciones nuevas (que no existan en la base de datos).



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

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:Colección creada para #{model}: ")
    else
      logger.información("MONGOID:opciones de colección ignoradas en: #{model}, defínalas en el modelo raíz.")
    end
  rescate Excepción
    logger.Error "Erroral crear la colección para #{model}"
    propagar
  end
end

# crear_índices(modelos =::Mongoid.models)⇒ Array<Class>

Crea índices para cada modelo dados los globs proporcionados y la clase no está incorporada.

Ejemplos:

Crea todos los índices.

Mongoid::Tasks::Database.create_indexes

Devuelve:

  • (Matriz<Class>) —

    Los modelos indexados.



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

def create_indexes(modelos = ::Mongoid.modelos)
  modelos.cada hacer |modelo|
    siguiente Si modelo.especificaciones del índice.¿vacío?
    Si !modelo.¿incorporado? || modelo.¿cíclico?
      modelo.create_indexes
      logger.información("MONGOID:Índices creados en #{model}: ")
      modelo.especificaciones del índice.cada hacer |especulación|
        logger.información("MONGOID:Índice: #{clave específica }, Opciones: #{opciones específicas}")
      end
      modelo
    else
      logger.información("MONGOID:Índice ignorado en: #{model}, defínalo en el modelo raíz.")
      nulo
    end
  end.compact
end

#create_search_indexes(modelos =::Mongoid.models, esperar: verdadero) ⇒ Objeto

Envíe solicitudes para la creación de los índices de búsqueda. Esto se realizará de forma asíncrona. Si "wait" es verdadero, el método se bloqueará mientras espera la creación de los índices.

Parámetros:

  • modelos (Matriz) (predeterminado:::Mongoid.models) —

    los modelos para compilar índices de búsqueda.

  • esperar (true | false) (predeterminado: verdadero)

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



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

def create_search_indexes(modelos = ::Mongoid.modelos, esperar: true)
  buscable = modelos.Seleccione { |m| m.especificaciones del índice de búsqueda.any? }

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

  esperar_a_los_índices_de_búsqueda(nombres de índice por modelo) Si esperar
end

#eliminar_índices(modelos =::Mongoid.models) ⇒ Array<Class>

Elimine los índices de cada modelo dados los globs proporcionados y la clase no está incorporada.

Ejemplos:

Eliminar todos los índices.

Mongoid::Tasks::Database.remove_indexes

Devuelve:

  • (Matriz<Class>) —

    Los modelos no indexados.



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

def remove_indexes(modelos = ::Mongoid.modelos)
  modelos.cada hacer |modelo|
    siguiente Si modelo.¿incorporado?
    begin
      modelo.remove_indexes
    rescate Mongo::Error::Operación fallida
      siguiente
    end
    modelo
  end.compact
end

#eliminar_índices_de_búsqueda(modelos =::Mongoid.models) ⇒ Objeto

Eliminar todos los índices de búsqueda de los modelos dados.



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

def eliminar_índices_de_búsqueda(modelos = ::Mongoid.modelos)
  modelos.cada hacer |modelo|
    siguiente Si modelo.¿incorporado?
    modelo.eliminar_índices_de_búsqueda
  end
end

#eliminar_índices_indefinidos(modelos =::Mongoid.models) ⇒ Hash{Clase => Matriz(Hash)}

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

Ejemplos:

Eliminar índices no definidos.

Mongoid::Tasks::Database.remove_undefined_indexes

Devuelve:

  • (Hash{Clase => Matriz(Hash)}) —

    La lista de índices que fueron eliminados por 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)
  índices indefinidos(modelos).cada hacer |modelo, indexes|
    indexes.cada hacer |index|
      clave = index['key'].simbolizar_claves
      Colección = modelo.Colección
      Colección.indexes(sesión: modelo.Enviar(:_sesión)).soltar uno(clave)
      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

#colecciones_de_fragmentos(modelos =::Mongoid.models) ⇒ Matriz<Class>

Colecciones de fragmentos para modelos que declaran claves de fragmentos.

Devuelve las clases de modelo cuyas colecciones fueron fragmentadas, incluidas las clases de modelo cuyas colecciones ya habían sido fragmentadas antes de la invocación de este método.

Ejemplos:

Fragmentar todas las colecciones

Mongoid::Tasks::Database.shard_collections

Devuelve:

  • (Matriz<Class>) —

    Los modelos fragmentados



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
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
242
243
 
# Archivo 'lib/mongoid/tasks/database.rb', línea 172

def colecciones de fragmentos(modelos = ::Mongoid.modelos)
  modelos.map hacer |modelo|
    siguiente Si modelo.shard_config.nil?

    Si modelo.¿incorporado? && !modelo.¿cíclico?
      logger.advertir("MONGOID:#{model} tiene configuración de fragmento pero estáincrustado")
      siguiente
    end

    a no ser que modelo.Colección.clúster.¿fragmentado?
      logger.advertir("MONGOID:#{model} tiene configuración de fragmento pero no se conserva en un clúster fragmentado: #{model.collection.cluster.summary}")
      siguiente
    end

    # La base de datos de la colección debe existir para poder 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
    #Una aproximación de esto es crear la colección que queremos.
    # En servidores más antiguos, crear una colección que ya existe es
    # un error.
    # Además, los servidores 3.6 y potencialmente más antiguos no proporcionan
    # el código de error cuando se les pide que collStats no exista
    # colección (https://jira.mongodb.org/browse/SERVER-50070).
    begin
      stats = modelo.Colección.database.Comando(collStats: modelo.Colección.Nombre).primera
    rescate Mongo::Error::Operación fallida => Excª
      # El código 26 es que la base de datos no existe.
      # El código 8 es una colección que no existe a partir de 4.0.
      # En 3.6 y anteriores, coincide con el texto del mensaje de excepción.
      Si Excª.Código == 26 || Excª.Código == 8 ||
        Excª.Código.nil? && Excª.Mensaje =~ /extraviado/
      entonces
        modelo.Colección.Cree

        stats = modelo.Colección.database.Comando(collStats: modelo.Colección.Nombre).primera
      else
        propagar
      end
    end

    stats = modelo.Colección.database.Comando(collStats: modelo.Colección.Nombre).primera
    Si stats[:fragmentado]
      logger.información("MONGOID:#{model.collection.namespace} ya está fragmentado para #{model }")
      siguiente modelo
    end

    base de datos de administración = modelo.Colección.Cliente.uso(:administración).database

    begin
      base de datos de administración.Comando(habilitar fragmentación: modelo.Colección.database.Nombre)
    rescate Mongo::Error::Operación fallida => Excª
      # El servidor 2.6 falla si el particionado ya está habilitado
      Si Excª.Código == 23 || Excª.Código.nil? && Excª.Mensaje =~ /ya habilitado/
        # Nada
      else
        propagar
      end
    end

    begin
      base de datos de administración.Comando(Colección de fragmentos: modelo.Colección.namespace, **modelo.shard_config)
    rescate Mongo::Error::Operación fallida => e
      logger.Error("MONGOID:No se pudo fragmentar la colección #{model.collection.namespace} para #{model}: #{e.class}: #{e }")
      siguiente
    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 modelo que existen en la base de datos pero no están especificados en los modelos.

Ejemplos:

Devuelve la lista de índices no utilizados.

Mongoid::Tasks::Database.undefined_indexes

Devuelve:

  • (Matriz<Hash>) —

    La lista de índices no definidos por modelo.



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 86

def índices indefinidos(modelos = ::Mongoid.modelos)
  indefinido_por_modelo = {}

  modelos.cada hacer |modelo|
    a no ser que modelo.¿incorporado?
      begin
        modelo.Colección.indexes(sesión: modelo.Enviar(:_sesión)).cada hacer |index|
          # ignore default index
          a no ser que index['nombre '] == '_id_'
            clave = index['key'].simbolizar_claves
            especulación = modelo.especificación_del_índice(clave, index['nombre '])
            a no ser que especulación
              # índice no especificado
              indefinido_por_modelo[modelo] ||= []
              indefinido_por_modelo[modelo] << index
            end
          end
        end
      rescate Mongo::Error::Operación fallida; end
    end
  end

  indefinido_por_modelo
end