ActionView::Template::Error (PG::UndefinedTable: ERROR: missing FROM-clause....

Question

予約管理アプリのバージョンアップを行っています。
rails6へバージョンアップをして、動作を確認しておりましたところ特定の画面で、下記のエラーが発生しました。

ActionView::Template::Error (PG::UndefinedTable: ERROR:  missing FROM-clause entry for table "company_groups"
 LINE 1: SELECT "companies".* FROM "companies" WHERE (company_groups....
 ^

 4:   .control-group
 5:     = f.label :company_id, :class => 'control-label'
 6:     .controls
 7:       = f.collection_select :company_id, Company.user_companies, :id, :name
 8:   .control-group
 9:     = f.label :service_unit_id, :class => 'control-label'
10:     .controls

app/views/admin/service_contracts/_form.html.haml:7
app/views/admin/service_contracts/_form.html.haml:2
app/views/admin/service_contracts/edit.html.haml:4

他の部分で同じエラーが出たのですが、それは下記の方法で修正しました。

Book.includes(calendar: :company).where("companies.id = ?", company).count

↓↓↓↓↓↓↓↓↓↓

Book.includes(calendar: :company).where("companies.id = ?", company).references(:companies).count

しかし、今回のエラーではどこを修正すればよいかわかりません。
どなたかご教授いただければ幸いです。
何卒宜しくお願い致します。

追記

class Company < ActiveRecord::Base

  GIGA = 1024 * 1024 * 1024

  default_scope { order("companies.id ASC") }

  include SecurityEngine

  validates_uniqueness_of :login_name
  validates_numericality_of :storage_capacity_gb,
    :greater_than_or_equal_to => :storage_size_needed_gb,
    :on => :update
  after_save :update_browsers

  has_many :browsers, dependent: :destroy
  has_many :drawers, dependent: :nullify
  has_many :service_contracts, dependent: :destroy
  has_many :service_units, through: :service_contracts
  has_many :credits, class_name: "Charge",
    foreign_key: :payee_id, dependent: :nullify
  has_many :debts, class_name: "Charge",
    foreign_key: :payer_id, dependent: :nullify
  belongs_to :account_type
  has_many :shops, :dependent => :destroy
  has_many :customers, :dependent => :destroy
  has_many :users, :dependent => :destroy
  has_many :generations,->{ order(:position) } ,:dependent => :destroy 
  has_many :custom_links, ->{ order(:position) }, :dependent => :destroy
  has_many :item_groups, ->{ order(:position) }, :dependent => :destroy
  has_many :items, :dependent => :destroy
  has_many :inventories, :dependent => :destroy
  has_many :deals, :dependent => :destroy
  has_many :sales, :dependent => :destroy
  has_many :occupations, :dependent => :destroy
  belongs_to :number_factory
  belongs_to :ymd_input_style
  has_many :custom_fields, :dependent => :destroy
  has_many :custom_field_items, :dependent => :destroy
  has_many :photos, :dependent => :destroy
  has_many :payment_types, :dependent => :destroy
  has_many :payments, :dependent => :destroy
  has_many :trend_cubes, :dependent => :destroy
  has_many :cubes, :dependent => :destroy
  has_many :stocks, :dependent => :destroy
  has_many :calendars, ->{ order(:position) }, :dependent => :destroy
  belongs_to :company_group
  belongs_to :manager, class_name: "User"
  belongs_to :sales_company, class_name: "Company"
  belongs_to :sales_person, class_name: "User"
  has_many :user_notifications, dependent: :nullify
  has_many :customer_notifications, dependent: :nullify

  before_save    :encrypt_privacy_information
  after_save     :decrypt_privacy_information
  after_find     :decrypt_privacy_information

  scope :managed_by_dealer, lambda {
    includes(:company_group).
    where("company_groups.has_grant_sale = ? OR company_groups.has_grant_use = ? OR company_groups.has_grant_billing = ?", true, true, true)
  }

  scope :providers, lambda {
    includes(:company_group).
    where("company_groups.has_grant_maintenance = ?", true)
  }

  scope :dealers, lambda {
    includes(:company_group).
    where("company_groups.has_grant_service = ?", true)
  }

  scope :user_companies, lambda {
    includes(:company_group).
    where("company_groups.has_grant_use = ?", true)
  }

  scope :actives_on, lambda { |date = Date.today|
    where("companies.end_at is null OR companies.end_at > ?", date)
  }

  def has_multi_shops?
    self.shops.count > 1
  end

  def first_sale
    self.sales.count > 0 ? self.sales.order("ordered_at ASC").first : nil
  end

  def sold(from = Date.today, to = Date.today)
    self.sales.during(from, to).sum(:final_price)
  end

  def paid(from = Date.today, to = Date.today)
    self.payments.actives.during(from, to).sum(:price)
  end

  def customers_at(d = Date.today)
    self.customers.where("start_at <= ?", d).order("start_at ASC")
  end

  def accounts_receivable(from = self.first_sale.ordered_at, to = Date.today)
    self.sold(from, to) - self.paid(from, to)
  end

  def storage_used
    self.photos.sum(:image_file_size)
  end

  def storage_size_needed_gb
    gb_needed = (1.0 * self.storage_used / GIGA).ceil
    [12, gb_needed].max
  end

  def storage_free_space
    self.storage_capacity_gb * GIGA - self.storage_used
  end

  def storage_used_percentage
    100 * self.storage_used / (self.storage_capacity_gb * GIGA)
  end

  def customers_with_large_debts(n = 10)
    self.customers.except(:order).order("accounts_receivable DESC").limit(n)
  end

  def ready?
    status = true

    status = status && (self.item_groups.count > 0)
    status = status && (self.items.count > 0)
    status = status && (self.payment_types.count > 0)
    status = status && (self.occupations.count > 0)
    status = status && (self.shops.count > 0)

    return status
  end

  def root_item_groups
    self.item_groups.roots.actives
  end

  def leaf_item_groups
    leafs = []
    self.item_groups.actives.each do |ig|
      leafs << ig if ig.leaf?
    end

    return leafs
  end

  def is_system_provider?
    self.company_group && self.company_group.has_grant_maintenance
  end

  def is_dealer?
    self.company_group && self.company_group.has_grant_service
  end

  def is_user?
    self.company_group && self.company_group.has_grant_use
  end

  def credit_amount
    self.credits.not_paid.sum(:amount)
  end

  def debt_amount
    self.debts.not_paid.sum(:amount)
  end

  def has_credits?
    self.credits.not_paid.count > 0
  end

  def has_debts?
    self.debts.not_paid.count > 0
  end

  def get_contract(service_unit)
    return nil if service_unit.nil?
    return self.service_contracts.where(service_unit_id: service_unit.id).first
  end

  def activate_service(service_unit, user)
    service_contract = get_contract(service_unit)

    if service_contract.nil? && service_unit
      service_contract = self.service_contracts.new(service_unit_id: service_unit.id)
    end

    return false if service_contract.nil?

    return service_contract.activate(user)
  end

  def deactivate_service(service_unit, user)
    service_contract = get_contract(service_unit)

    return false if service_contract.nil?
    return service_contract.deactivate(user)
  end

  def using?(service_unit)
    service_contract = get_contract(service_unit)
    return service_contract ? service_contract.active : false
  end

  def monthly_charge
    self.service_contracts.actives.sum(:price)
  end

  def basic_contract
    self.service_contracts.actives.each do |sc|
      return sc if sc.service_unit.mandatory
    end
    return nil
  end

  def option_service_units
    return self.basic_contract.service_unit.option_service_units
  end

  def has_bank_info?
    return false if self.bank_name.blank?
    return false if self.bank_branch.blank?
    return false unless self.account_type
    return false unless self.account_number
    return !self.account_name.blank?
  end

  def num_of_books_without_sale
    return self.calendars.inject(0) do |num_books, calendar|
      num_books += calendar.books.without_sale.count
    end
  end

  def num_of_books_in_today
    return self.calendars.inject(0) do |num_books, calendar|
      num_books += calendar.books.of_day(Date.today).count
    end
  end

  def has_drawer?
    self.drawers.count > 0
  end

  def is_using?(service_unit_name_tag)
    if self.service_units.with_name_tag(service_unit_name_tag).count > 0
      return true
    end

    ServiceUnit.with_name_tag(service_unit_name_tag).each do |su|
      self.service_units.each do |s|
        return true if s.includes?(su)
      end
    end

    return false
  end

  def pusher_channel
    return "Company-%d" % self.id
  end

  def active?
    return true if self.end_at.nil?
    return self.end_at > Date.today
  end

  private
    def encrypt_privacy_information
      self.bank_name      = encrypt(self.bank_name)
      self.bank_branch    = encrypt(self.bank_branch)
      self.account_number = encrypt(self.account_number)
      self.account_name   = encrypt(self.account_name)
    end
  
    def decrypt_privacy_information
      self.bank_name      = decrypt(self.bank_name)
      self.bank_branch    = decrypt(self.bank_branch)
      self.account_number = decrypt(self.account_number)
      self.account_name   = decrypt(self.account_name)
    end

    def update_browsers
      unless self.manage_browser
        self.browsers.each do |b|
          b.logout
        end
      end
    end
end

Comments

[neko_daisuki]

company.rb を追記してください

[jnpps]

ご指摘ありがとうございます
追加いたします。

Answer 1

以下のいずれかの記述にしてみてください。

  scope :user_companies, lambda {
    includes(:company_group).
    where(company_groups: { has_grant_use: true })
  }

  scope :user_companies, lambda {
    includes(:company_group).
    references(:company_group).
    where("company_groups.has_grant_use = ?", true)
  }

  scope :user_companies, lambda {
    joins(:company_group).
    where("company_groups.has_grant_use = ?", true)
  }

ここからはあまり自身がないのですが、includes は where の内容によって振る舞いが変わるようです。
company_groups.has_grant_use = ? と指定すると、どのテーブルを参照しているか分からず
テーブルを結合しないで検索してしまうため、このエラーが出るのでしょう。

なのでハッシュで表記するか references で結合するテーブルであることを教えて上げます。

また、includes と joins では includes は指定したテーブルをキャッシュしますが、joins はしません。

User.joins(:posts).each do |user|
  # joins は結果をキャッシュしないので
  # ここを通るたび(user の数だけ)何回も SQL が発行される
  user.posts
end

User.includes(:posts).each do |user|
  # includes は posts を最初にまとめて読み込んでキャッシュしているため SQL は発行されない
  user.posts
end

ActiveRecordのjoinsとpreloadとincludesとeager_loadの違い

Comments

[jnpps]

ご丁寧にありがとうございます。二つ目の references(:company_group).を追加したところ問題なく動作いたしました。とても助かりました。