ActiveRecord.find (array_of_ids), с сохранением порядка

Когда вы делаете это Something.find(array_of_ids)в Rails, порядок результирующего массива не зависит от порядка array_of_ids.

Есть ли способ сделать поиск и сохранить порядок?

Банкомат Я вручную сортирую записи в соответствии с порядком идентификаторов, но это отчасти неубедительно.

UPD: если можно указать порядок с помощью :orderпараметра и какого-то SQL-предложения, то как?

Ответ только для mysql

В mysql есть функция FIELD ()

Вот как вы можете использовать его в .find ():

>> ids = [100, 1, 6]
=> [100, 1, 6]

>> WordDocument.find(ids).collect(&:id)
=> [1, 6, 100]

>> WordDocument.find(ids, :order => "field(id, #{ids.join(',')})")
=> [100, 1, 6]

For new Version
>> WordDocument.where(id: ids).order("field(id, #{ids.join ','})")

Обновление: это будет удалено в исходном коде Rails 6.1 Rails.

Как ни странно, никто не предлагал ничего подобного:

index = Something.find(array_of_ids).group_by(&:id)
array_of_ids.map { |i| index[i].first }

Насколько он эффективен, если не считать того, что это делает серверная часть SQL.

Изменить: чтобы улучшить мой собственный ответ, вы также можете сделать это так:

Something.find(array_of_ids).index_by(&:id).slice(*array_of_ids).values

#index_byи #sliceявляются довольно удобными дополнениями в ActiveSupport для массивов и хэшей соответственно.

Как заявил Майк Вудхаус в своем ответе , это происходит потому, что под капотом Rails использует SQL-запрос с a WHERE id IN... clauseдля получения всех записей в одном запросе. Это быстрее, чем получение каждого идентификатора по отдельности, но, как вы заметили, он не сохраняет порядок извлекаемых записей.

Чтобы исправить это, вы можете отсортировать записи на уровне приложения в соответствии с исходным списком идентификаторов, которые вы использовали при поиске записи.

Основываясь на множестве отличных ответов о сортировке массива по элементам другого массива , я рекомендую следующее решение:

Something.find(array_of_ids).sort_by{|thing| array_of_ids.index thing.id}

Или, если вам нужно что-то немного более быстрое (но, возможно, менее читаемое), вы можете сделать это:

Something.find(array_of_ids).index_by(&:id).values_at(*array_of_ids)

Кажется, это работает для postgresql ( источник ) и возвращает отношение ActiveRecord

class Something < ActiveRecrd::Base

  scope :for_ids_with_order, ->(ids) {
    order = sanitize_sql_array(
      ["position((',' || id::text || ',') in ?)", ids.join(',') + ',']
    )
    where(:id => ids).order(order)
  }    
end

# usage:
Something.for_ids_with_order([1, 3, 2])

может быть расширен и для других столбцов, например, для nameстолбца используйте position(name::text in ?)...

Как я здесь ответил , я только что выпустил гем ( order_as_specified ), который позволяет вам выполнять нативное упорядочивание SQL следующим образом:

Something.find(array_of_ids).order_as_specified(id: array_of_ids)

Насколько мне удалось проверить, он изначально работает во всех СУБД и возвращает отношение ActiveRecord, которое можно связать в цепочку.

Невозможно в SQL, который работал бы во всех случаях, к сожалению, вам нужно будет либо писать отдельные находки для каждой записи или заказа в ruby, хотя, вероятно, есть способ заставить его работать, используя проприетарные методы:

Первый пример:

sorted = arr.inject([]){|res, val| res << Model.find(val)}

ОЧЕНЬ НЕЭФФЕКТИВНЫЙ

Второй пример:

unsorted = Model.find(arr)
sorted = arr.inject([]){|res, val| res << unsorted.detect {|u| u.id == val}}

Ответ @Gunchars отличный, но он не работает из коробки в Rails 2.3, потому что класс Hash не упорядочен. Простым обходным index_byпутем является расширение класса Enumerable для использования класса OrderedHash:

module Enumerable
  def index_by_with_ordered_hash
    inject(ActiveSupport::OrderedHash.new) do |accum, elem|
      accum[yield(elem)] = elem
      accum
    end
  end
  alias_method_chain :index_by, :ordered_hash
end

Теперь подход @Gunchars будет работать

Something.find(array_of_ids).index_by(&:id).slice(*array_of_ids).values

Бонус

module ActiveRecord
  class Base
    def self.find_with_relevance(array_of_ids)
      array_of_ids = Array(array_of_ids) unless array_of_ids.is_a?(Array)
      self.find(array_of_ids).index_by(&:id).slice(*array_of_ids).values
    end
  end
end

затем

Something.find_with_relevance(array_of_ids)

Предполагая Model.pluck(:id)возврат, [1,2,3,4]и вам нужен порядок[2,4,1,3]

Идея состоит в том, чтобы использовать предложение ORDER BY CASE WHENSQL. Например:

SELECT * FROM colors
  ORDER BY
  CASE
    WHEN code='blue' THEN 1
    WHEN code='yellow' THEN 2
    WHEN code='green' THEN 3
    WHEN code='red' THEN 4
    ELSE 5
  END, name;

В Rails вы можете добиться этого, используя в своей модели общедоступный метод для построения аналогичной структуры:

def self.order_by_ids(ids)
  if ids.present?
    order_by = ["CASE"]
    ids.each_with_index do |id, index|
      order_by << "WHEN id='#{id}' THEN #{index}"
    end
    order_by << "END"
    order(order_by.join(" "))
  end
else
  all # If no ids, just return all
end

Затем сделайте:

ordered_by_ids = [2,4,1,3]

results = Model.where(id: ordered_by_ids).order_by_ids(ordered_by_ids)

results.class # Model::ActiveRecord_Relation < ActiveRecord::Relation

Это хорошо. Результаты возвращаются как ActiveRecord отношений ( что позволяет использовать такие методы , как last, count, where, pluckи т.д.)

Существует драгоценный камень find_with_order, который позволяет вам делать это эффективно, используя собственный SQL-запрос.

И он поддерживает как, так Mysqlи PostgreSQL.

Например:

Something.find_with_order(array_of_ids)

Если вы хотите отношения:

Something.where_with_order(:id, array_of_ids)

Под капотом findс массивом идентификаторов будет сгенерировано предложение SELECTс WHERE id IN...предложением, что должно быть более эффективным, чем цикл по идентификаторам.

Таким образом, запрос удовлетворяется за одно обращение к базе данных, но SELECTобъекты без ORDER BYпредложений не сортируются. ActiveRecord понимает это, поэтому мы расширяем наше findследующим образом:

Something.find(array_of_ids, :order => 'id')

Если порядок идентификаторов в вашем массиве является произвольным и значительным (то есть вы хотите, чтобы порядок возвращаемых строк соответствовал вашему массиву независимо от последовательности идентификаторов, содержащихся в нем), тогда я думаю, что вы будете лучшим сервером, постобработав результаты в код - вы можете создать :orderпредложение, но оно будет чертовски сложным и совсем не раскрывает намерения.

Хотя я нигде не упоминаю об этом в CHANGELOG, похоже, что эта функция была изменена с выпуском версии5.2.0 .

Здесь фиксируется обновление документов, помеченных как. 5.2.0Однако, похоже, он также был перенесен в версию 5.0.

Что касается ответа здесь

Object.where(id: ids).order("position(id::text in '#{ids.join(',')}')") работает для Postgresql.

В find (: order => '...') есть предложение порядка, которое делает это при выборке записей. Здесь вы также можете получить помощь.

текст ссылки