Classe: Mongoid::Contextual::Mongo::DocumentsLoader Private

Herda:
Objeto
  • Objeto
mostrar tudo
Estendido por:
Encaminhável
Inclui:
Associação::EagerLoadable
Definido em:
lib/mongoid/contextual/mongo/documents_loader.rb

Visão geral

Esta classe faz parte de uma API privada. Evite usar essa classe, se possível, pois ela pode ser removida ou alterada no futuro.

Carrega documentos para os critérios fornecidos.

Recolhimento do Resumo do atributo de instância

Recolhimento do Resumo do método de classe

Recolhimento do Resumo do método de instância

Métodos incluídos de Associação::EagerLoadable

#eager_load, #eager_loadable?, #preload

Detalhes do construtor

#inicializar(visualização, klass, critérios, executor: self. classe.executor) ➤ DocumentsLoader

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Instancia a instância do carregador de documento e agenda imediatamente sua execução usando o executor fornecido.

Parâmetros:

  • vista (Mongo::Collection::View) —

    A visualização de collection para obter registros do banco de banco de dados.

  • classe (Classe) —

    classe de modelo Mongoid para instanciar documentos. Todos os registros obtidos do banco de banco de dados serão convertidos em uma instância dessa classe, se possível.

  • critério (Mongoid::Criteria) —

    Critérios que especificam quais documentos devem ser carregados.

  • executor (Concurrent::AbstractExecutorService) (padrão para: self. classe.executor) —

    Executor que é capaz de executar instâncias 'Concurrent::Promises::Future'.



89
90
91
92
93
94
95
96
97
98
 
# File 'lib/mongoid/contextual/mongo/documents_loader.rb', linha 89

def inicializar(vista, classe, critério, executor: auto.classe.executor)
  @view = vista
  @klass = classe
  @criteria = critério
  @mutex = Mutex.Novo
  @state = :pending
  @future = Simultâneo::Promessas.futuro_on(executor) fazer
    iniciar && executar, executar
  end
end

Detalhes do atributo da instância

#criteria ⇒ Mongoid::Criteria

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna critérios que especificam quais documentos devem ser carregados. Exposto aqui porque o método 'eager_loadable?' de `Association::EagerLoadable' espera que isso esteja disponível.

Retorna:

  • (Mongoid::Criteria) —

    Critérios que especificam quais documentos devem ser carregados. Exposto aqui porque o método 'eager_loadable?' de `Association::EagerLoadable' espera que isso esteja disponível.



75
76
77
 
# File 'lib/mongoid/contextual/mongo/documents_loader.rb', linha 75

def critério
  @criteria
end

Detalhes do método de classe

.executor(name = Mongoid.async_query_executor) ➤ Concurrent::ImmediateExecutor | Concurrent::ThreadPoolExecutor

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna o executor adequado de acordo com as opções de configuração do Mongoid.

Parâmetros:

  • name (string | Símbolo) (padrão para: Mongoid.async_query_executor) —

    O nome do executor da query pode ser :immediate ou :global_thread_pool. Padrão para a opção de configuração 'async_query_executor'.

Retorna:

  • (Concurrent::ImmediateExecutor | Concurrent::ThreadPoolExecutor) —

    O executor a ser usado para executar tarefas de carregamento de documento .

Aumenta:



61
62
63
64
65
66
67
68
69
70
 
# File 'lib/mongoid/contextual/mongo/documents_loader.rb', linha 61

def auto.executor(name = Mongoid.async_query_executor)
  caso name.to_sym
  quando :immediate
    imediato_executor
  quando :global_thread_pool
    global_thread_pool_async_query_executor
  mais
    aumentar Errors::InvalidQueryExecutor.Novo(name)
  end
end

.global_thread_pool_async_query_executor ➤ Concurrent::ThreadPoolExecutor

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna o executor assíncrono para ser usado quando a opção de configuração async_query_executor estiver definida como :global_thread_pool. Este executor executa operações em threads de background usando um pool de threads.

Retorna:

  • (Concurrent::ThreadPoolExecutor) —

    O executor a ser usado para executar tarefas de carregamento de documento .



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/mongoid/contextual/mongo/documents_loader.rb', linha 32

def auto.global_thread_pool_async_query_executor
  create_pool = Proc.Novo fazer |Concurrency|
    Simultâneo::ThreadPoolExecutor.Novo(
      min_threads: 0,
      max_threads: Concurrency,
      max_queue: Concurrency * 4,
      fallback_policy: :caller_runs
    )
  end
  Concurrency = Mongoid.global_executor_concurrency || 4
  @@global_thread_pool_async_query_executor ||= create_pool.Chame(Concurrency)
  se @@global_thread_pool_async_query_executor.max_long != Concurrency
    old_pool = @@global_thread_pool_async_query_executor
    @@global_thread_pool_async_query_executor = create_pool.Chame(Concurrency)
    old_pool.desligar
  end
  @@global_thread_pool_async_query_executor
end

.ImediateExecutor ➤ Concurrent::ImmediateExecutor

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna o executor síncrono a ser usado quando a opção de configuração async_query_executor é definida como :immediate. Este executor executa todas as operações no thread atual, bloqueando conforme necessário.

Retorna:

  • (Concurrent::ImmediateExecutor) —

    O executor a ser usado para executar tarefas de carregamento de documento .



22
23
24
 
# File 'lib/mongoid/contextual/mongo/documents_loader.rb', linha 22

def auto.imediato_executor
  @@immediate_executor ||= Simultâneo::ImmediateExecutor.Novo
end

Detalhes do método de instância

#execute ➤ Array<Mongoid::Document>

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Carrega registros especificados por '@criteria' do banco de dados e os converte em documentos Mongoid do tipo '@klass'.

Este método é chamado pela tarefa (possivelmente assíncrona) agendada ao criar uma instância do carregador. No entanto, esse método pode ser chamado diretamente, se for desejado executar o carregamento no thread do chamador imediatamente.

Chamar este método não altera o estado do carregador.

Retorna:

  • (Array <Mongoid::Document>) —

    Array de documento carregados do banco de banco de dados.



152
153
154
155
156
157
158
 
# File 'lib/mongoid/contextual/mongo/documents_loader.rb', linha 152

def executar, executar
  documentos = @view.map fazer |doc|
    Factory.from_db(@klass, doc, @criteria)
  end
  modified_load(documentos) se ans_loadable?
  documentos
end

#pendente? ➤ verdadeiro | false

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna falso ou verdadeiro se o carregador está no estado pendente.

Estado pendente significa que a execução do carregador foi agendada, mas ainda não foi iniciada.

Retorna:

  • (verdadeiro | falso) —

    true se o carregador estiver em estado pendente; caso contrário, false.



107
108
109
110
111
 
# File 'lib/mongoid/contextual/mongo/documents_loader.rb', linha 107

def pendente?
  @mutex.sincronizar fazer
    @state == :pending
  end
end

#começou? ➤ verdadeiro | false

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna falso ou verdadeiro se o carregador está no estado iniciado.

Estado iniciado significa que a execução do carregador foi iniciada. Observe que o carregador permanece nesse estado mesmo após a conclusão da execução (com sucesso ou com falha).

Retorna:

  • (verdadeiro | falso) —

    true se o carregador estiver no estado iniciado, caso contrário, false.



121
122
123
124
125
 
# File 'lib/mongoid/contextual/mongo/documents_loader.rb', linha 121

def começou?
  @mutex.sincronizar fazer
    @state == :started
  end
end

#desagendar ➤ Objeto

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Marque o carregador como não programado.

Se o carregador estiver marcado como não programado, ele não será executado. A única opção para carregar os documentos é chamar o método "execute" diretamente.

Observe que, se a execução de uma tarefa já tiver sido iniciada, o desagendamento não terá nenhum efeito.



134
135
136
137
138
 
# File 'lib/mongoid/contextual/mongo/documents_loader.rb', linha 134

def desagendar
  @mutex.sincronizar fazer
    @state = :cancelado a menos que @state == :started
  end
end