Rails self-referential association join conditions - ruby-on-rails

Question

I have the following database schema and models, which constitute a self-referential association where a Phrase has many translations of other Phrases, through the Translation association:
Schema:
ActiveRecord::Schema.define(version: 20151003213732) do
enable_extension "plpgsql"
create_table "phrases", force: :cascade do |t|
t.integer "language"
t.string "text"
end
create_table "translations", force: :cascade do |t|
t.integer "source_id"
t.integer "destination_id"
end
end
Phrase:
class Phrase < ActiveRecord::Base
has_many :translations,
class_name: "Translation",
foreign_key: "source_id"
has_many :destination_phrases,
through: :translations
has_many :inverse_translations,
class_name: "Translation",
foreign_key: "destination_id"
has_many :source_phrases,
through: :inverse_translations
enum language: [:eng, :spa, ...]
end
Translation:
class Translation < ActiveRecord::Base
belongs_to :source_phrase,
class_name: "Phrase",
foreign_key: "source_id"
belongs_to :destination_phrase,
class_name: "Phrase",
foreign_key: "destination_id"
end
Now, I want to run queries based on source language and destination language. For example, I want to find English phrases and their respective Spanish translations. Currently I am querying phrases based on source language, but then I have to filter out the results using the select method on the destination language. What I have looks like the following:
#translations = Translation.includes(:source_phrase, :destination_phrase)
.where(phrases: {language: #source_language})
# Select only destination phrases where the language matches
#translations = #translations.select {
|t| t.destination_phrase.language == #destination_language
}
I want to eliminate the select call because this should definitely be possible in ActiveRecord. The select would be replaced by an additional parameter in the model's where query, but I cant figure out how to specify it.
It should look something like this:
#translations =
Translation.includes(:source_phrase, :destination_phrase)
.where([source_phrase: {language: #source_language},
destination_phrase: {language: #destination_language}])
However, ActiveRecord thinks (rightfully) that source_phrase and destination_phrase in the where clause are table names. So the table name still has to be phrases, but when it is I can't specify the join condition for both joins, just the first.
How can I specify 2 separate join conditions on a self-referential association which both access the same attribute on the same model (language on the Phrase model)?

Answer 1

My Phrase model turned out to be defined incorrectly, which was the first problem. I've revised it as so:
Phrase:
class Phrase < ActiveRecord::Base
has_many :translations,
class_name: "Translation",
foreign_key: "source_id"
has_many :source_phrases, # this changed
through: :translations
has_many :inverse_translations,
class_name: "Translation",
foreign_key: "destination_id"
has_many :destination_phrases, # this changed
through: :inverse_translations
enum language: [:eng, :spa, ...]
end
Translation has remained the same:
class Translation < ActiveRecord::Base
belongs_to :source_phrase,
class_name: "Phrase",
foreign_key: "source_id"
belongs_to :destination_phrase,
class_name: "Phrase",
foreign_key: "destination_id"
end
Now I am able to perform either of the following queries to get the correct results:
Translation
.includes(:source_phrase => :source_phrases, :destination_phrase => :destination_phrases)
.where(source_phrases_phrases: {language: 0}, destination_phrases_phrases: {language: 2})
or
Translation
.joins(:source_phrase => :source_phrases, :destination_phrase => :destination_phrases)
.where(source_phrases_phrases: {language: 0}, destination_phrases_phrases: {language: 2})
.distinct
The answer was in specifying the joined association (in this case source_phrases and destination_phrases in Phrase), which could then be used as different table names in the where clause.
I should note that I use source_phrases_phrases and destination_phrases_phrases in the where clause because Rails seems to expect the table name (phrases) to be appended to the associations (source_phrases and destination_phrases). It makes for a few ugly queries, but perhaps I could name my associations in the Phrase model better...
It also seems that from the EXPLAIN output (way too long to put here), the joins version is about 25% faster with 6,000 phrases and 12,000 translations. It also exponentially gets faster the larger those tables grow.
Lesson learned? Self-referential associations are a pain. I certainly hope that this helps someone in the future.