Como eu escrevo um método localizador do Rails em que nenhum dos itens has_many possui um campo diferente de nulo?

Estou usando o Rails 5. Tenho o seguinte modelo ...

class Order < ApplicationRecord
    ...
    has_many :line_items, :dependent => :destroy

O modelo LineItem possui um atributo, "discount_applied". Gostaria de devolver todos os pedidos em que existem zero instâncias de um item de linha, com o campo "discount_applied" não sendo nulo. Como escrevo esse método localizador?

Não é eficiente, mas achei que poderia resolver o seu problema:

orders = Order.includes(:line_items).select do |order|
  order.line_items.all? { |line_item| line_item.discount_applied.nil? }
end

Atualização :

Em vez de encontrar pedidos com todos os seus itens de linha sem desconto, podemos excluir todos os pedidos com itens de linha com desconto aplicado no resultado da saída. Isso pode ser feito com subconsulta dentro da cláusula where:

# Find all ids of orders which have line items with a discount applied:
excluded_ids = LineItem.select(:order_id)
                       .where.not(discount_applied: nil)
                       .distinct.map(&:order_id)

# exclude those ids from all orders:
Order.where.not(id: excluded_ids)

Você pode combiná-los em um único método localizador:

Order.where.not(id: LineItem
                    .select(:order_id)
                    .where.not(discount_applied: nil))

Espero que isto ajude

Antes de tudo, isso realmente depende se você deseja ou não usar uma abordagem Arel pura ou se o SQL é bom. O primeiro é IMO somente recomendável se você pretende criar uma biblioteca, mas desnecessário se estiver criando um aplicativo em que, na realidade, é altamente improvável que você esteja alterando seu DBMS ao longo do caminho (e, se o fizer, alterando algumas consultas manuais provavelmente serão o menor dos seus problemas).

Supondo que o uso do SQL seja bom, a solução mais simples que deve funcionar em praticamente todos os bancos de dados é:

Order.where("(SELECT COUNT(*) FROM line_items WHERE line_items.order_id = orders.id AND line_items.discount_applied IS NULL) = 0")

Isso também deve funcionar praticamente em qualquer lugar (e tem um pouco mais de Arel e menos SQL manual):

Order.left_joins(:line_items).where(line_items: { discount_applied: nil }).group("orders.id").having("COUNT(line_items.id) = 0")

Dependendo do DBMS específico (mais especificamente: seu respectivo otimizador de consulta), um ou outro pode ter melhor desempenho.

Espero que ajude.

Um código possível

Order.includes(:line_items).where.not(line_items: {discount_applied: nil})

Eu aconselho a se familiarizar com a documentação do AR para Métodos de Consulta.

Atualizar

Isso parece estar mais interessado do que eu pensava inicialmente. E mais complicado, então não poderei fornecer um código funcional. Mas eu procuraria uma solução usando LineItem.group(order_id).having(discount_applied: nil), que deve fornecer uma coleção de itens de linha e depois usá-la como subconsulta para encontrar pedidos relacionados.

Se você deseja que todos os registros onde discount_applied seja nulo, então:

Order.includes(:line_items).where.not(line_items: {discount_applied: nil})

(o uso inclui para evitar o problema n + 1) ou

Order.joins(:line_items).where.not(line_items: {discount_applied: nil})

Aqui está a solução para o seu problema

order_ids = Order.joins(:line_items).where.not(line_items: {discount_applied: nil}).pluck(:id)
orders = Order.where.not(id: order_ids)

A primeira consulta retornará IDs de Orderspelo menos um line_itemtendo discount_applied. A segunda consulta retornará tudo ordersonde houver zero instâncias de um line_itemtendo o discount_applied.

Eu usaria o NOT EXISTSrecurso do SQL, que está disponível pelo menos no MySQL e no PostgreSQL

deve ficar assim

class Order
  has_many :line_items
  scope :without_discounts, -> {
    where("NOT EXISTS (?)", line_items.where("discount_applied is not null")
  }
end

Se entendi corretamente, você deseja obter todos os pedidos para os quais nenhum item de linha (se houver) tem um desconto aplicado.

Uma maneira de obter esses pedidos ActiveRecordseria o seguinte:

Order.distinct.left_outer_joins(:line_items).where(line_items: { discount_applied: nil })

Aqui está uma breve explicação de como isso funciona:

• A solução usa left_outer_joins, desde que você não acesse os itens de linha de cada pedido. Você também pode usar left_joins, que é um alias.
• Se você precisar instanciar os itens de linha para cada Orderinstância, adicione .eager_load(:line_items)à cadeia que impedirá a realização de uma consulta adicional para cada pedido (N + 1), ou seja, order.line_items.eachem uma exibição.
• O uso distincté essencial para garantir que os pedidos sejam incluídos apenas uma vez no resultado.

Atualizar

Minha solução anterior foi verificar apenas discount_applied IS NULLpelo menos um item de linha, não todos. A consulta a seguir deve retornar os pedidos necessários.

Order.left_joins(:line_items).group(:id).having("COUNT(line_items.discount_applied) = ?", 0)

Isto é o que está acontecendo:

• A solução ainda precisa usar uma junção externa esquerda ( orders LEFT OUTER JOIN line_items) para incluir pedidos sem itens associados.
• Agrupa os itens de linha para obter um único Orderobjeto, independentemente de quantos itens ele possui ( GROUP BY recipes.id).
• Ele conta o número de itens de linha que receberam um desconto para cada pedido, selecionando apenas aqueles cujos itens têm descontos zero aplicados ( HAVING (COUNT(line_items.discount_applied) = 0)).

Espero que ajude.

Você não pode fazer isso de forma eficiente com os trilhos clássicos left_joins, mas a junção esquerda do sql foi criada para lidar com esses casos

Order.joins("LEFT JOIN line_items AS li ON li.order_id = orders.id 
                                       AND li.discount_applied IS NOT NULL")
     .where("li.id IS NULL")

Uma junção interna simples retornará todos os pedidos, juntamente com todos os itens de linha,
mas se não houver itens de linha para esse pedido, a ordem será ignorada (como um falso onde)
Com a junção esquerda, se nenhum item de linha for encontrado, o sql o unirá a um entrada vazia para mantê-lo

Então, partimos para os line_items que não queremos e localizamos todos os pedidos com um line_items vazio

E evite todo o código com where(id: pluck(:id))ou having("COUNT(*) = 0"), no dia isso matará seu banco de dados