cheerfulstoic
commented
10 years ago Ok, so I think I've figured out a solution that will please. Below is an example to explore the core problem. The second part is a proposal for how to deal with it. I believe it will work mostly like neo4j 2.x, except the relationships just have #association and not Model#association as the type. That seemed prudent to sidestep with class inheritance, but happy to hear arguments.
class Person
include Neo4j::ActiveNode
has_many :enemies, model: Person
has_many :friends, model: Person
end
class SuperHuman < Person
include Neo4j::ActiveNode
end
class SuperHero < SuperHuman
include Neo4j::ActiveNode
has_many :powers
end
class SuperVillain < SuperHuman
include Neo4j::ActiveNode
has_many :powers
end
class Power
include Neo4j::ActiveNode
has_many :super_humans
end
spidey = SuperHero.create(name: 'Spiderman')
mj = Person.create(name: 'Mary Jane')
doc_oc = SuperVillain.create(name: 'Doctor Octavius')
web_slinging = Power.create(name: 'Web Slinging')
spidey_sense = Power.create(name: 'Spidey Sense')
extra_arms = Power.create(name: 'Extra Arms')
spidey.powers << web_slinging # CREATE spidey-[:`#powers`]->webSlinging
spidey.powers << spidey_sense # CREATE spidey-[:`#powers`]->spideySense
doc_oc.powers << extra_arms # CREATE docOc-[:`#powers`]->extraArms
extra_arms.super_humans.to_a
# MATCH extraArms-[:`#super_humans`]-(result:SuperHuman) # DOESN'T WORK
# MATCH extraArms-[:`#powers`]-(result:SuperHuman) # WORKS, SHOULD WE EVEN TRY TO FIGURE THIS OUT?
# MATCH extraArms--(result:SuperHuman) # WORKS
spidey.friends << mj # CREATE spidey-[:`#friends`]->mj
spidey.enemies << doc_oc # CREATE spidey-[:`#enemies`]->docOc
spidey.friends.to_a
# MATCH spidey-[:`#friends`]-(result:Person) # WORKS
# MATCH spidey--(result:Person) # TOO MANY RESULTS
mj.friends.to_a
# MATCH mj-[:`#friends`]-(result:Person) # WORKS
# Proposal on various forms of has_many
# This declaration implies that we want all associated Name nodes, regardless of relationship type
has_many :names
# CREATE -[:`#names`]->(:Name)
# MATCH --(:Name)
has_many :names, from: :bar
# CREATE <-[:`bar`]-(:Name)
# MATCH <-[:`bar`]-(:Name)
has_many :names, via: :bar
# CREATE -[:`bar`]->(:Name)
# MATCH -[:`bar`]->(:Name)
has_many :names, with: :bar
# CREATE -[:`bar`]->(:Name)
# MATCH -[:`bar`]-(:Name)
# Using the :model key changes the label. Examples:
has_many :names, model: Foo, from: :bar
# CREATE <-[:`bar`]-(:Foo)
# MATCH <-[:`bar`]-(:Foo)
# IMPORTANT CASE:
# When we specify model, but not the relationship, we should query on the relationship name based off of the association name
has_many :names, model: Foo
# CREATE -[:`#names`]->(:Foo)
# MATCH -[:`#names`]-(:Foo)
# Since the association name resolves to the same thing as the model, consider to be the same as has_many :names
has_many :names, :model: Name
# CREATE -[:`#names`]->(:Name)
# MATCH --(:Name)
subvertallchris
andreasronge
Check out the query_experiment branch. For good examples see the query_spec:
https://github.com/andreasronge/neo4j/blob/query_experiment/spec/e2e/query_spec.rb
The code is a bit hairy right now, but I'm really excited about this approach. It takes over some of the conceptual ground of QuickQuery without the .qq method, it introduces a more ActiveRecordy has_many association, and it allows for calling class methods on QueryProxy objects (which are also now returned from has_many associations)
This is aping a lot of ActiveRecord, but I think it's taking it a step beyond what ActiveRecord is capable of doing. I'm really excited about it ;)
Some things that would need to be done: