Convertendo uma matriz de objetos para ActiveRecord :: Relation

Eu tenho uma série de objetos, vamos chamá-la de Indicator. Eu quero executar métodos de classe Indicator (aqueles da def self.subjectsvariedade, escopos, etc) neste array. A única maneira que conheço de executar métodos de classe em um grupo de objetos é fazer com que sejam um ActiveRecord :: Relation. Então acabo recorrendo à adição de um to_indicatorsmétodo a Array.

def to_indicators
  # TODO: Make this less terrible.
  Indicator.where id: self.pluck(:id)
end

Às vezes, eu encadeamento alguns desses escopos para filtrar os resultados, dentro dos métodos de classe. Portanto, embora eu chame um método em um ActiveRecord :: Relation, não sei como acessar esse objeto. Eu só consigo acessar o conteúdo dela all. Mas allé um Array. Então, eu tenho que converter esse array para um ActiveRecord :: Relation. Por exemplo, isso faz parte de um dos métodos:

all.to_indicators.applicable_for_bank(id).each do |indicator|
  total += indicator.residual_risk_for(id)
  indicator_count += 1 if indicator.completed_by?(id)
end

Acho que isso se resume a duas perguntas.

1. Como posso converter um Array de objetos em um ActiveRecord :: Relation? De preferência sem fazer um a wherecada vez.
2. Ao executar um def self.subjectsmétodo de tipo em um ActiveRecord :: Relation, como faço para acessar o próprio objeto ActiveRecord :: Relation?

Obrigado. Se eu precisar esclarecer alguma coisa, me avise.

Como posso converter um Array de objetos em um ActiveRecord :: Relation? De preferência, sem fazer um onde cada vez.

Você não pode converter um Array em um ActiveRecord :: Relation, pois um Relation é apenas um construtor para uma consulta SQL e seus métodos não operam em dados reais.

No entanto, se o que você deseja é uma relação:

• para ActiveRecord 3.x, não chame alle sim chame scoped, o que retornará um Relation que representa os mesmos registros que allvocê daria em um Array.

• para ActiveRecord 4.x, basta chamar all, que retorna uma relação.

Ao executar um def self.subjectsmétodo de tipo em um ActiveRecord :: Relation, como faço para acessar o próprio objeto ActiveRecord :: Relation?

Quando o método é chamado em um objeto Relation, selfé a relação (em oposição à classe de modelo em que é definida).

Você pode converter uma matriz de objetos arrem um ActiveRecord :: Relation como este (assumindo que você sabe a qual classe os objetos são, o que provavelmente você sabe)

MyModel.where(id: arr.map(&:id))

Você tem que usar where, porém, é uma ferramenta útil que você não deve hesitar em usar. E agora você tem uma linha convertendo um array em uma relação.

map(&:id)irá transformar seu array de objetos em um array contendo apenas seus ids. E passar uma matriz para uma cláusula where gerará uma instrução SQL com a INseguinte aparência:

SELECT .... WHERE `my_models`.id IN (2, 3, 4, 6, ....

Lembre-se de que a ordem do array será perdida - mas como seu objetivo é apenas executar um método de classe na coleção desses objetos, presumo que não seja um problema.

Bem, no meu caso, eu preciso converter uma matriz de objetos para ActiveRecord :: Relation , bem como classificá- los com uma coluna específica (id por exemplo). Como estou usando o MySQL, a função de campo pode ser útil.

MyModel.where('id in (?)',ids).order("field(id,#{ids.join(",")})") 

O SQL se parece com:

SELECT ... FROM ... WHERE (id in (11,5,6,7,8,9,10))  
ORDER BY field(id,11,5,6,7,8,9,10)

Função de campo MySQL

ActiveRecord::Relation vincula consulta de banco de dados que recupera dados do banco de dados.

Suponha que para fazer sentido, temos array com objetos da mesma classe, então com que consulta supomos ligá-los?

Quando eu corro,

users = User.where(id: [1,3,4,5])
  User Load (0.6ms)  SELECT `users`.* FROM `users` WHERE `users`.`id` IN (1, 3, 4, 5)  ORDER BY created_at desc

Aqui acima, usersretorna o Relationobjeto, mas vincula a consulta do banco de dados por trás dele e você pode visualizá-lo,

users.to_sql
 => "SELECT `users`.* FROM `users` WHERE `users`.`id` IN (1, 3, 4, 5)  ORDER BY created_at desc"

Portanto, não é possível retornar ActiveRecord::Relationde um array de objetos que seja independente da consulta sql.

Em primeiro lugar, esta NÃO é uma bala de prata. Com base na minha experiência, descobri que a conversão às vezes é mais fácil do que as alternativas. Tento usar essa abordagem com moderação e apenas nos casos em que a alternativa seria mais complexa.

Dito isso, aqui está a minha solução, estendi a Arrayaula

# lib/core_ext/array.rb

class Array

  def to_activerecord_relation
    return ApplicationRecord.none if self.empty?

    clazzes = self.collect(&:class).uniq
    raise 'Array cannot be converted to ActiveRecord::Relation since it does not have same elements' if clazzes.size > 1

    clazz = clazzes.first
    raise 'Element class is not ApplicationRecord and as such cannot be converted' unless clazz.ancestors.include? ApplicationRecord

    clazz.where(id: self.collect(&:id))
  end
end

Um exemplo de uso seria array.to_activerecord_relation.update_all(status: 'finished'). Agora, onde eu uso?

Às vezes, você precisa filtrar, ActiveRecord::Relationpor exemplo, remover elementos não concluídos. Nesses casos, o melhor é usar o escopo elements.not_finishede você ainda manteria ActiveRecord::Relation.

Mas às vezes essa condição é mais complexa. Retire todos os elementos que não estão acabados e que foram produzidos nas últimas 4 semanas e foram inspecionados. Para evitar a criação de novos escopos, você pode filtrar para uma matriz e depois converter de volta. Lembre-se de que você ainda faz uma consulta ao DB, rápido, pois ele pesquisa por, idmas ainda é uma consulta.