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

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

Overview

Módulo de utilidad para administrar colecciones de bases de datos, índices, fragmentación, 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>) —

    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) (por defecto: false) —

    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: 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 "Erroral crear la colección para #{model}"
    propagar
  end
end

#create_indexes(models = ::Mongoid.models) ⇒ arreglo<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:

  • (arreglo<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 #{modelo}:")
      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: #{modelo}, por favor, define en el modelo raíz.")
      nulo
    end
  end.compact
end

#create_search_indexes(models = ::Mongoid.models, wait: true) ⇒ 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 (arreglo<Mongoid::documento>) (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.Seleccionar { |m| m.search_index_specs.any? }

  # poner en cola las solicitudes de creación de índices de búsqueda
  nombres de índice 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 índice 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
 
# 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::OperationFailure
      siguiente
    end
    Modelo
  end.compact
end

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

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



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

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

#remove_undefined_indexes(models = ::Mongoid.models) ⇒ Hash{clase => arreglo(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 => 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'].simbolizar_claves
      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 fragmentos para modelos que declaran claves de fragmentos.

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



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.advertencia("MONGOID: #{modelo} tiene configuración de partición pero está embebido")
      siguiente
    end

    a menos que Modelo.Colección.clúster.¿fragmentado?
      logger.advertencia("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 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 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
      stats = Modelo.Colección.database.Comando(collStats: Modelo.Colección.Nombre).primero
    rescate Mongo::Error::OperationFailure => Excª
      # 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 Excª.Código == 26 || Excª.Código == 8 ||
        Excª.Código.nil? && Excª.mensaje =~ /no encontrado/
      entonces
        Modelo.Colección.Cree

        stats = 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[:fragmentado]
      logger.información("MONGOID:#{model.collection.namespace} ya está fragmentado para #{model }")
      siguiente 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 => Excª
      # El servidor 2.6 falla si el particionado ya está habilitado
      si Excª.Código == 23 || Excª.Código.nil? && Excª.mensaje =~ /ya está activado/
        # Nada
      else
        propagar
      end
    end

    begin
      admin_db.Comando(Colección de fragmentos: 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}")
      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:

  • (arreglo<Hash>) —

    La lista de índices indefinidos 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 undefined_indexes(modelos = ::Mongoid.modelos)
  undefined_by_model = {}

  modelos.cada hacer |Modelo|
    a menos que Modelo.¿Incorporado?
      begin
        Modelo.Colección.indexes(sesión: Modelo.enviar(:_session)).cada hacer |index|
          # ignore default index
          a menos que index['nombre'] == '_id_'
            llave = index['key'].simbolizar_claves
            especulación = Modelo.especificación_del_índice(llave, index['nombre'])
            a menos que especulación
              # índice no especificado
              undefined_by_model[Modelo] ||= []
              undefined_by_model[Modelo] << index
            end
          end
        end
      rescate Mongo::Error::OperationFailure; end
    end
  end

  undefined_by_model
end