Módulo: Mongoid::Tarefas::banco de dados

Estendido por:
Database
Incluído em:
Database
Definido em:
lib/mongoid/tasks/ banco de dados.rb

Visão geral

Módulo utilitário para gerenciar collections de banco de dados de dados, índices, fragmentação etc. Invocado a partir de tarefas do Rake.

Recolhimento do Resumo do método de instância

Detalhes do método de instância

#create_collections(models = ::Mongoid.models, force: falso) ➤ Objeto

Crie coleções para cada modelo, dados os globals fornecidos e a classe não está incorporada.

Parâmetros:

  • modelos. (Array <Mongoid::Document>) —

    Array de classes de documento para as quais as collections devem ser criadas. Padrão para todas as classes de documento do aplicação.

  • força (verdadeiro | falso) (padrão para: false) —

    Se verdadeiro, o método descartará as collections existentes antes de criar novas. Se falso, o método criará somente nova coleção (que não existe no banco de banco de dados).



21
22
23
24
25
26
27
28
29
30
31
32
33
 
# Arquivo 'lib/mongoid/tasks/ banco de dados.rb', linha 21

def create_collections(modelos = ::Mongoid.modelos, força: false)
  modelos.cada fazer |Modelo|
    se !Modelo.incorporado? || Modelo.cíclica?
      Modelo.create_collection(força: força)
      logger.informações("MONGOID: Criou a collection para #{model}:")
    mais
      logger.informações("MONGOID: opções de coleção ignoradas em: #{modelo}, defina no modelo raiz.")
    end
  salvar Exceção
    logger.Erro "erro ao criar coleção para #{modelo}"
    aumentar
  end
end

#create_indexes(models = ::Mongoid.models) ➤ Array<Class>

Crie índices para cada modelo, dados os globals fornecidos, e a classe não está incorporada.

Exemplos:

Crie todos os índices.

Mongoid::Tasks::Database.create_indexes

Retorna:

  • (Array<Class>) —

    Os modelos indexados.



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# Arquivo 'lib/mongoid/tasks/ banco de dados.rb', linha 42

def create_indexes(modelos = ::Mongoid.modelos)
  modelos.cada fazer |Modelo|
    próximo se Modelo.index_specifications.vazio?
    se !Modelo.incorporado? || Modelo.cíclica?
      Modelo.create_indexes
      logger.informações("MONGOID: Índices criados no #{modelo}:")
      Modelo.index_specifications.cada fazer |especificações|
        logger.informações("MONGOID: Índice: #{spec.key}, Options: #{spec.options}")
      end
      Modelo
    mais
      logger.informações("MONGOID: Índice ignorado em: #{model}, defina no modelo raiz.")
      nada
    end
  end.compactar
end

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

Envie solicitações para os índices de pesquisa a serem criados. Isso acontecerá de forma assíncrona. Se "wait" for verdadeiro, o método bloqueará enquanto aguarda a criação dos índices.

Parâmetros:

  • modelos (Array <Mongoid::Document>) (padrão para: ::Mongoid.models) —

    os modelos para os quais criar índices de pesquisa.

  • esperar (verdadeiro | falso) (padrão para: true) —

    se deve esperar a criação dos índices.



67
68
69
70
71
72
73
74
75
76
77
 
# Arquivo 'lib/mongoid/tasks/ banco de dados.rb', linha 67

def create_search_indexes(modelos = ::Mongoid.modelos, Aguarde: true)
  pesquisável = modelos.selecione { |m| m.search_index_specs.algum? }

  # enfileirar as solicitações de criação do índice de pesquisa
  index_names_by_model = pesquisável.cada_com_objeto({}) fazer |Modelo, obj|
    logger.informações("MONGOID: Criando índices de pesquisa no #{modelo}...")
    obj[Modelo] = Modelo.create_search_indexes
  end

  wait_for_search_indexes(index_names_by_model) se esperar
end

#remove_indexes(models = ::Mongoid.models) ➤ Array<Class>

Remova índices para cada modelo, dados os globals fornecidos, e a classe não está incorporada.

Exemplos:

Remova todos os índices.

Mongoid::Tasks::Database.remove_indexes

Retorna:

  • (Array<Class>) —

    Os modelos não indexados.



139
140
141
142
143
144
145
146
147
148
149
 
# Arquivo 'lib/mongoid/tasks/ banco de dados.rb', linha 139

def remove_indexes(modelos = ::Mongoid.modelos)
  modelos.cada fazer |Modelo|
    próximo se Modelo.incorporado?
    começar
      Modelo.remove_indexes
    salvar mongo::Erro::Falha de operação
      próximo
    end
    Modelo
  end.compactar
end

#remove_search_indexes(models = ::Mongoid.models) ➤ Objeto

Remova todos os índices de pesquisa dos modelos fornecidos.



155
156
157
158
159
160
 
# Arquivo 'lib/mongoid/tasks/ banco de dados.rb', linha 155

def remove_search_indexes(modelos = ::Mongoid.modelos)
  modelos.cada fazer |Modelo|
    próximo se Modelo.incorporado?
    Modelo.remove_search_indexes
  end
end

#remove_undefinited_indexes(models = ::Mongoid.models) ➤ Hash{Class => Array(Hash)}

Remova os índices existentes no banco de dados de dados, mas não especificados nos modelos.

Exemplos:

Remova índices indefinidos.

Mongoid::Tasks::Database.remove_undefined_indexes

Retorna:

  • (Hash{Classe => Array(Hash)}) —

    A lista de índices que foram removidos por modelo.



118
119
120
121
122
123
124
125
126
127
128
129
130
 
# Arquivo 'lib/mongoid/tasks/ banco de dados.rb', linha 118

def remove_undefinited_indexes(modelos = ::Mongoid.modelos)
  undefinition_indexes(modelos).cada fazer |Modelo, Índices|
    Índices.cada fazer |index|
      chave = index['key'].symbolize_keys
      collection = Modelo.collection
      collection.Índices(sessão: Modelo.enviar(:_session)).drop_one(chave)
      logger.informações(
        "MONGOID: índice removido '#{índice['nome']}' na coleção " +
        "'#{coleção.nome}'no banco de dados de dados'#{coleção.banco de dadosde dados.nome}'."
      )
    end
  end
end

#shard_collections(models = ::Mongoid.models) ➤ Array<Class>

Collections de shard para modelos que declaram chaves de shard.

Retorna as classes de modelo que tiveram suas coleções fragmentadas, incluindo as classes de modelo cujas coleções já tinham sido fragmentadas antes da invocação deste método.

Exemplos:

Fragmentar todas as coleções

Mongoid::Tasks::Database.shard_collections

Retorna:

  • (Array<Class>) —

    Os 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
 
# Arquivo 'lib/mongoid/tasks/ banco de dados.rb', linha 172

def shard_collections(modelos = ::Mongoid.modelos)
  modelos.map fazer |Modelo|
    próximo se Modelo.shard_config.nada?

    se Modelo.incorporado? && !Modelo.cíclica?
      logger.AVISAR("MONGOID: #{modelo} tem configuração de fragmento, mas está incorporado")
      próximo
    end

    a menos que Modelo.collection.cluster.fragmentado?
      logger.AVISAR("MONGOID: #{modelo} tem configuração de fragmento, mas não é persistente em um cluster fragmentado: #{modelo.coleção.cluster.resumo}")
      próximo
    end

    # O banco de dados da collection deve existir para executar collStats.
    # Dependendo da versão do servidor , a própria collection também deve
    #existe.
    # O MongoDB não tem um comando para criar o banco de dados; o melhor
    # aproximação dele é criar a collection que queremos.
    # Em servidores mais antigos, criar uma coleção que já existe é
    # um erro.
    # Além disso, 3.6 e servidores potencialmente mais antigos não fornecem
    # o código de erro quando são solicitados a collStats um inexistente
    # collection (https://jira.mongodb.org/browse/SERVER-{050070).
    começar
      estatísticas = Modelo.collection.database.comando(Estatísticas da Coll: Modelo.collection.name).primeiro
    salvar mongo::Erro::Falha de operação => exc
      #O código 26 no banco de banco de dados não existe.
      # O código 8 da coleção não existe, a partir de 4.0.
      # Em 3.6 e anteriores, corresponda ao texto da mensagem de exceção.
      se exc.código == 26 || exc.código == 8 ||
        exc.código.nada? && exc.mensagem =~ /não encontrado/
      então
        Modelo.collection.criar

        estatísticas = Modelo.collection.database.comando(Estatísticas da Coll: Modelo.collection.name).primeiro
      mais
        aumentar
      end
    end

    estatísticas = Modelo.collection.database.comando(Estatísticas da Coll: Modelo.collection.name).primeiro
    se estatísticas[:sharded]
      logger.informações("MONGOID: #{modelo.collection.namespace} já está fragmentado para #{modelo}")
      próximo Modelo
    end

    admin_db = Modelo.collection.Cliente.Usar(: admin).database

    começar
      admin_db.comando(enableSharding: Modelo.collection.database.name)
    salvar mongo::Erro::Falha de operação => exc
      # Servidor MongoDB 2.6 falhará se a fragmentação já estiver habilitada
      se exc.código == 23 || exc.código.nada? && exc.mensagem =~ /já habilitado/
        #Nada
      mais
        aumentar
      end
    end

    começar
      admin_db.comando(shardCollection: Modelo.collection.namespace, **Modelo.shard_config)
    salvar mongo::Erro::Falha de operação => e
      logger.Erro("MONGOID: falha ao fragmentar a coleção #{modelo.coleção.namespace} para #{modelo}: #{e.classe}: #{e}")
      próximo
    end

    logger.informações("MONGOID: coleção fragmentada #{modelo.collection.namespace} para #{modelo}")

    Modelo
  end.compactar
end

#indefinido_indexes(models = ::Mongoid.models) ➤ Array<Hash>

Retornar a lista de índices por modelo que existem no banco de dados de dados, mas não são especificados nos modelos.

Exemplos:

Retornar a lista de índices não utilizados.

Mongoid::Tasks::Database.undefined_indexes

Retorna:

  • (Array<Hash>) —

    A 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
 
# Arquivo 'lib/mongoid/tasks/ banco de dados.rb', linha 86

def undefinition_indexes(modelos = ::Mongoid.modelos)
  indefinido_by_model = {}

  modelos.cada fazer |Modelo|
    a menos que Modelo.incorporado?
      começar
        Modelo.collection.Índices(sessão: Modelo.enviar(:_session)).cada fazer |index|
          # ignore default index
          a menos que index['nome'] == '_id_'
            chave = index['key'].symbolize_keys
            especificações = Modelo.index_specificação(chave, index['nome'])
            a menos que especificações
              # índice não especificado
              indefinido_by_model[Modelo] ||= []
              indefinido_by_model[Modelo] << index
            end
          end
        end
      salvar mongo::Erro::Falha de operação; end
    end
  end

  indefinido_by_model
end