Rails和ActiveRecord-重构多个相同的where子句

Question

I'm on Rails 5.

I've got to deal with a pretty complex query with multiple identical where clauses :

::AllocatedBudget.joins(:account_code, :budget, account_code: [:place],
                          budget: [:fiscal_year, :budget_state])
                    .where(immeuble:            { id: place.id })
                    .where(situation_budget:    { codesituation: ['A', 'V']})
                    .where(plan_comptable:      { supprime: 'false' })
                    .where(budget:              { supprime: 'false'})
                    .where(situation_budget:    { supprime: 'false' })
                    .where(budget_previsionnel: { supprime: 'false' })
                    .where(exercice_comptable:  { supprime: 'false' })

First, you must know that my models are connected to an old database with ugly names. I've noticed that ActiveRecord need the custom names instead the models's names to perform the queries. I don't know why but it works only that way... If somebody could explain that it would be nice ;)

My real question is : can I write it in a better way ? There is so many time the same where clause "supprime = 'false' ".

Thanks a lot ! :)

Answer 1

I would break the problem into two steps

1. Create a hash of all your conditions using pure ruby code
2. Pass the entire hash into where .

So step one is something like this.

same_conditions_list = [
  :plan_comptable, 
  :budget, 
  :situation_budget, 
  :budget_previsionnel, 
  :exercice_comptable
]

same_conditions_key_values = same_conditions_list.inject({}) do |conditions, condition|
  conditions[condition] = { supprime: 'false' }
  conditions
end   

same_conditions = Hash[same_conditions_key_values]      

all_conditions = same_conditions.merge({
  immeuble: { id: "place.id" }
})       

After that all_conditions will equal this

{
  :plan_comptable=>{:supprime=>"false"},
  :budget=>{:supprime=>"false"},
  :situation_budget=>{:supprime=>"false"},
  :budget_previsionnel=>{:supprime=>"false"},
  :exercice_comptable=>{:supprime=>"false"},
  :immeuble=>{:id=>"place.id"}
}

Then step two would just be

::AllocatedBudget.joins(:account_code, :budget, account_code: [:place],
                      budget: [:fiscal_year, :budget_state])
                  .where(all_conditions)

Answer 2

Finaly I tried the design pattern "Query Object" with a mix of the solution of AndrewSwerlick

module QueryObject
  class AllocatedBudgetQuery

    def self.call(filters = {}, relation = ::AllocatedBudget.all)
      new(filters, relation).tap(&:call)
    end

    # filter can have the key/value as follow (key are symbols) :
    # place_id/string
    # current_fiscal_year/boolean
    # budget_state/['A', 'V', '*']
    def initialize(filters = {}, relation = ::AllocatedBudget.all)
      @relation     = relation
      @filters      = filters
    end

    def call
      conditions = {
        budget_previsionnel: { supprime: 'false' },
        budget: { supprime: 'false' }
      }

      # place filter
      conditions = conditions.merge(immeuble: { id: @filters[:place_id] }) if @filters.key?(:place_id)

      # situation budget filter
      conditions = conditions.merge(situation_budget: { codesituation: @filters[:budget_state] }) if @filters.key?(:budget_state)

      # main extract
      @relation = @relation.joins(:account_code,
                                  account_code: [:place],
                                  budget: %i[fiscal_year budget_state])
                           .where(conditions)

      # current fiscal year filter
      @relation = @relation.where("#{Date.today.to_s} between exercice_comptable.datedebutexercice and exercice_comptable.datefinexercice") if @filters.key?(:current_fiscal_year)
    end
  end
end