Was macht inverse_of? Welches SQL wird generiert?

Ich versuche meinen Kopf herumzukriegen inverse_ofund ich verstehe es nicht.

Wie sieht die generierte SQL aus, wenn überhaupt?

Hat die inverse_ofzeigen Option das gleiche Verhalten verwendet , wenn sie mit :has_many, :belongs_tound :has_many_and_belongs_to?

Entschuldigung, wenn dies eine so grundlegende Frage ist.

Ich habe dieses Beispiel gesehen:

class Player < ActiveRecord::Base
  has_many :cards, :inverse_of => :player
end

class Card < ActiveRecord::Base
  belongs_to :player, :inverse_of => :cards
end

Aus der Dokumentation geht hervor , dass die :inverse_ofOption eine Methode ist, um SQL-Abfragen zu vermeiden und nicht zu generieren. Es ist ein Hinweis für ActiveRecord, bereits geladene Daten zu verwenden, anstatt sie erneut über eine Beziehung abzurufen.

Ihr Beispiel:

class Dungeon < ActiveRecord::Base
  has_many :traps, :inverse_of => :dungeon
  has_one :evil_wizard, :inverse_of => :dungeon
end

class Trap < ActiveRecord::Base
  belongs_to :dungeon, :inverse_of => :traps
end

class EvilWizard < ActiveRecord::Base
  belongs_to :dungeon, :inverse_of => :evil_wizard
end

In diesem Fall dungeon.traps.first.dungeonsollte der Aufruf das ursprüngliche dungeonObjekt zurückgeben, anstatt ein neues zu laden, wie dies standardmäßig der Fall wäre.

Ich denke, es :inverse_ofist am nützlichsten, wenn Sie mit Assoziationen arbeiten, die noch nicht bestehen. Z.B:

class Project < ActiveRecord::Base
  has_many :tasks, :inverse_of=>:project
end

class Task < ActiveRecord::Base
  belongs_to :project, :inverse_of=>:tasks
end

Nun in der Konsole:

irb> p = Project.new
=> #<Project id: nil, name: nil, ...>
irb> t = p.tasks.build
=> #<Task id: nil, project_id: nil, ...>
irb> t.project
=> #<Project id: nil, name: nil, ...>

Ohne die :inverse_ofArgumente t.projectwürde zurückgegeben nil, da es eine SQL-Abfrage auslöst und die Daten noch nicht gespeichert sind. Mit den :inverse_ofArgumenten werden die Daten aus dem Speicher abgerufen.

Nach diesem PR ( https://github.com/rails/rails/pull/9522 ) ist inverse_of in den meisten Fällen nicht erforderlich.

Active Record unterstützt die automatische Identifizierung für die meisten Zuordnungen mit Standardnamen. Active Record erkennt jedoch nicht automatisch bidirektionale Zuordnungen, die einen Bereich oder eine der folgenden Optionen enthalten:

• :durch
• :Unbekannter Schlüssel

class Author < ApplicationRecord
  has_many :books, inverse_of: 'writer'
end

class Book < ApplicationRecord
  belongs_to :writer, class_name: 'Author', foreign_key: 'author_id'
end

a = Author.first
b = a.books.first
a.first_name == b.writer.first_name # => true
a.first_name = 'David'
a.first_name == b.writer.first_name # => true

Im obigen Beispiel wird ein Verweis auf dasselbe Objekt in der Variablen aund im Attribut gespeichert writer.

Nur ein Update für alle - wir haben es nur inverse_ofmit einer unserer Apps mit einer has_many :throughAssoziation verwendet

Grundsätzlich stellt es das "Ursprungs" -Objekt dem "untergeordneten" Objekt zur Verfügung

Wenn Sie also das Beispiel von Rails verwenden:

class Dungeon < ActiveRecord::Base
  has_many :traps, :inverse_of => :dungeon
  has_one :evil_wizard, :inverse_of => :dungeon
end

class Trap < ActiveRecord::Base
  belongs_to :dungeon, :inverse_of => :traps
  validates :id,
      :presence => { :message => "Dungeon ID Required", :unless => :draft? }

  private
  def draft?
      self.dungeon.draft
  end 
end

class EvilWizard < ActiveRecord::Base
  belongs_to :dungeon, :inverse_of => :evil_wizard
end

Mit :inverse_ofkönnen Sie auf das Datenobjekt zugreifen, von dem es umgekehrt ist, ohne weitere SQL-Abfragen ausführen zu müssen

Wenn wir zwei Modelle mit has_many und Zugehörigkeit zu Beziehung haben, ist es immer besser, inverse_of zu verwenden, die ActiveRecod darüber informieren, dass sie zur selben Seite der Zuordnung gehören. Wenn also eine Abfrage von einer Seite ausgelöst wird, wird sie zwischengespeichert und aus dem Cache bereitgestellt, wenn sie aus der entgegengesetzten Richtung ausgelöst wird. Was die Leistung verbessert. Ab Rails 4.1 wird inverse_of automatisch festgelegt. Wenn wir den Schlüssel fremd verwenden oder den Klassennamen ändern, müssen wir ihn explizit festlegen.

Bester Artikel für Details und Beispiel.

http://viget.com/extend/exploring-the-inverse-of-option-on-rails-model-associations

Schauen Sie sich diesen Artikel an !!

http://gsusmonzon.blogspot.com.br/2011/09/rails-power-of-inverseof.html

Wenn Sie eine has_many_throughBeziehung zwischen zwei Modellen, Benutzer und Rolle, haben und die Zuordnung des Verbindungsmodells für nicht vorhandene oder ungültige Einträge mit validieren möchten validates_presence of :user_id, :role_id, ist dies hilfreich. Sie können weiterhin einen User @user mit seiner Zuordnung generieren, @user.role(params[:role_id])damit das Speichern des Benutzers nicht zu einer fehlgeschlagenen Validierung des Zuweisungsmodells führt.

Bitte werfen Sie einen Blick auf zwei nützliche Ressourcen

• https://www.viget.com/articles/exploring-the-inverse-of-option-on-rails-model-associations
• http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Bi-directional+associations

Und denken Sie an einige Einschränkungen von inverse_of:

funktioniert nicht mit: durch Assoziationen.

funktioniert nicht mit: polymorphen Assoziationen.

Für Zugehörigkeitszuordnungen werden viele inverse Zuordnungen ignoriert.