rasti-db 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 898bf83981559ff4a054d73ad018a7f07e65d1a3
-  data.tar.gz: dda154478784631a4683281364c43d249db3356c
+  metadata.gz: 935cee1239288342a27bdcde6660f205b9fa1685
+  data.tar.gz: 2bc7b5c0cf6559c7ae5716b4814fea412e0481f3
 SHA512:
-  metadata.gz: cf9dacf0e63b028ad3ac4a32fcaff83dbb3b355ee02f60782d85203c2d931015e5ec1aa7cbcbc35b54ab943a3fb78f62970ebde2680d603d5998547ba3c347a4
-  data.tar.gz: ad67c48927b98ae619bd7c80fd044f518d26d906ff238972ab07871d987f2ccd616230b34c6816c0e5f49a928ba6bc77436c1834a71a21675cb8f546299d72a4
+  metadata.gz: b564fb1e883999d26e06b73c81d5ef68a68c2cdebc870403376c7c3b49e4729c020b552a010ffa47c13ca24743dfe9327b12963000a8892c55b3a4d0477f9170
+  data.tar.gz: 1f68b62bc955b2d7a4955a217877d9013c2ab7546740a0b90c452952e5cc241fa2573a7c1766da724e22013dfa176894c4ec81aa2da20bf322f0b84598f2ff63

data/lib/rasti/db/collection.rb

@@ -12,13 +12,17 @@ module Rasti
         include Sequel::Inflections
 
         def collection_name
-          @collection_name ||= implicit_collection_name
+          @collection_name ||= underscore(demodulize(name)).to_sym
         end
 
         def primary_key
           @primary_key ||= :id
         end
 
+        def foreign_key
+          @foreign_key ||= "#{singularize(collection_name)}_id".to_sym
+        end
+
         def model
           if @model.is_a? Class
             @model
@@ -37,14 +41,6 @@ module Rasti
           @queries ||= {}
         end
 
-        def implicit_collection_name
-          underscore(demodulize(name)).to_sym
-        end
-
-        def implicit_foreign_key_name
-          "#{singularize(collection_name)}_id".to_sym
-        end
-
         private
 
         def set_collection_name(collection_name)
@@ -55,11 +51,15 @@ module Rasti
           @primary_key = primary_key
         end
 
+        def set_foreign_key(foreign_key)
+          @foreign_key = foreign_key
+        end
+
         def set_model(model)
           @model = model
         end
 
-        [Relations::OneToMany, Relations::ManyToOne, Relations::ManyToMany].each do |relation_class|
+        [Relations::OneToMany, Relations::ManyToOne, Relations::ManyToMany, Relations::OneToOne].each do |relation_class|
           define_method underscore(demodulize(relation_class.name)) do |name, options={}|
             relations[name] = relation_class.new name, self, options
 
@@ -228,7 +228,7 @@ module Rasti
           delete_relation_table relation, primary_keys
         end
 
-        relations.select(&:one_to_many?).each do |relation|
+        relations.select { |r| r.one_to_many? || r.one_to_one? }.each do |relation|
           relation_collection_name = with_schema(relation.target_collection_class.collection_name)
           relations_ids = db[relation_collection_name].where(relation.foreign_key => primary_keys)
                                                       .select(relation.target_collection_class.primary_key)

data/lib/rasti/db/query.rb

@@ -99,7 +99,7 @@ module Rasti
 
       def with_graph(data)
         rows = data.is_a?(Array) ? data : [data]
-        Relations.graph_to rows, relations, collection_class, dataset.db, schema
+        Relations::GraphBuilder.graph_to rows, relations, collection_class, dataset.db, schema
         data
       end
 

data/lib/rasti/db/relations/base.rb

@@ -0,0 +1,51 @@
+module Rasti
+  module DB
+    module Relations
+      class Base
+        
+        include Sequel::Inflections
+
+        attr_reader :name, :source_collection_class
+
+        def initialize(name, source_collection_class, options={})
+          @name = name
+          @source_collection_class = source_collection_class
+          @options = options
+        end
+
+        def target_collection_class
+          @target_collection_class ||= options[:collection].is_a?(Class) ? options[:collection] : Consty.get(options[:collection] || camelize(pluralize(name)), source_collection_class)
+        end
+
+        def one_to_many?
+          self.class == OneToMany
+        end
+
+        def many_to_one?
+          self.class == ManyToOne
+        end
+
+        def many_to_many?
+          self.class == ManyToMany
+        end
+
+        def one_to_one?
+          self.class == OneToOne
+        end
+
+        private
+
+        attr_reader :options
+
+        def qualified_source_collection_name(schema=nil)
+          schema.nil? ? source_collection_class.collection_name : Sequel.qualify(schema, source_collection_class.collection_name)
+        end
+
+        def qualified_target_collection_name(schema=nil)
+          schema.nil? ? target_collection_class.collection_name : Sequel.qualify(schema, target_collection_class.collection_name)
+        end
+        
+      end
+    end
+  end
+end

data/lib/rasti/db/relations/graph_builder.rb

@@ -0,0 +1,31 @@
+module Rasti
+  module DB
+    module Relations
+      class GraphBuilder
+        class << self
+
+          def graph_to(rows, relations, collection_class, db, schema=nil)
+            return if rows.empty?
+
+            parse(relations).each do |relation, nested_relations|
+              raise "Undefined relation #{relation} for #{collection_class}" unless collection_class.relations.key? relation
+              collection_class.relations[relation].graph_to rows, db, schema, nested_relations
+            end
+          end
+
+          private
+
+          def parse(relations)
+            relations.each_with_object({}) do |relation, hash|
+              tail = relation.to_s.split '.'
+              head = tail.shift.to_sym
+              hash[head] ||= []
+              hash[head] << tail.join('.') unless tail.empty?
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/relations/many_to_many.rb

@@ -0,0 +1,60 @@
+module Rasti
+  module DB
+    module Relations
+      class ManyToMany < Base
+
+        def source_foreign_key
+          @source_foreign_key ||= options[:source_foreign_key] || source_collection_class.foreign_key
+        end
+
+        def target_foreign_key
+          @target_foreign_key ||= options[:target_foreign_key] || target_collection_class.foreign_key
+        end
+
+        def relation_collection_name
+          @relation_collection_name ||= options[:relation_collection_name] || [source_collection_class.collection_name, target_collection_class.collection_name].sort.join('_').to_sym
+        end
+
+        def qualified_relation_collection_name(schema=nil)
+          schema.nil? ? relation_collection_name : Sequel.qualify(schema, relation_collection_name)
+        end
+
+        def graph_to(rows, db, schema=nil, relations=[])
+          pks = rows.map { |row| row[source_collection_class.primary_key] }
+
+          target_collection = target_collection_class.new db, schema
+
+          relation_name = qualified_relation_collection_name schema
+
+          join_rows = target_collection.dataset
+                                       .join(relation_name, target_foreign_key => target_collection_class.primary_key)
+                                       .where(Sequel.qualify(relation_name, source_foreign_key) => pks)
+                                       .select_all(qualified_target_collection_name(schema))
+                                       .select_append(Sequel.qualify(relation_name, source_foreign_key).as(:source_foreign_key))
+                                       .all
+
+          GraphBuilder.graph_to join_rows, relations, target_collection_class, db, schema
+
+          relation_rows = join_rows.each_with_object(Hash.new { |h,k| h[k] = [] }) do |row, hash| 
+            attributes = row.select { |attr,_| target_collection_class.model.attributes.include? attr }
+            hash[row[:source_foreign_key]] << target_collection_class.model.new(attributes)
+          end
+
+          rows.each do |row| 
+            row[name] = relation_rows.fetch row[target_collection_class.primary_key], []
+          end
+        end
+
+        def apply_filter(dataset, schema=nil, primary_keys=[])
+          relation_name = qualified_relation_collection_name schema
+
+          dataset.join(relation_name, source_foreign_key => target_collection_class.primary_key)
+                 .where(Sequel.qualify(relation_name, target_foreign_key) => primary_keys)
+                 .select_all(qualified_source_collection_name(schema))
+                 .distinct
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/relations/many_to_one.rb

@@ -0,0 +1,33 @@
+module Rasti
+  module DB
+    module Relations
+      class ManyToOne < Base
+
+        def foreign_key
+          @foreign_key ||= options[:foreign_key] || target_collection_class.foreign_key
+        end
+
+        def graph_to(rows, db, schema=nil, relations=[])
+          fks = rows.map { |row| row[foreign_key] }.uniq
+
+          target_collection = target_collection_class.new db, schema
+
+          relation_rows = target_collection.where(source_collection_class.primary_key => fks)
+                                           .graph(*relations)
+                                           .each_with_object({}) do |row, hash| 
+                                              hash[row.public_send(source_collection_class.primary_key)] = row
+                                            end
+          
+          rows.each do |row| 
+            row[name] = relation_rows[row[foreign_key]]
+          end
+        end
+
+        def apply_filter(dataset, schema=nil, primary_keys=[])
+          dataset.where(foreign_key => primary_keys)
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/relations/one_to_many.rb

@@ -0,0 +1,42 @@
+module Rasti
+  module DB
+    module Relations
+      class OneToMany < Base
+
+        def foreign_key
+          @foreign_key ||= options[:foreign_key] || source_collection_class.foreign_key
+        end
+
+        def graph_to(rows, db, schema=nil, relations=[])
+          pks = rows.map { |row| row[source_collection_class.primary_key] }.uniq
+
+          target_collection = target_collection_class.new db, schema
+
+          relation_rows = target_collection.where(foreign_key => pks)
+                                           .graph(*relations)
+                                           .group_by { |r| r.public_send(foreign_key) }
+
+          rows.each do |row| 
+            row[name] = build_graph_result relation_rows.fetch(row[source_collection_class.primary_key], [])
+          end
+        end
+
+        def apply_filter(dataset, schema=nil, primary_keys=[])
+          target_name = qualified_target_collection_name schema
+
+          dataset.join(target_name, foreign_key => source_collection_class.primary_key)
+                 .where(Sequel.qualify(target_name, target_collection_class.primary_key) => primary_keys)
+                 .select_all(qualified_source_collection_name(schema))
+                 .distinct
+        end
+
+        private
+
+        def build_graph_result(rows)
+          rows
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/relations/one_to_one.rb

@@ -0,0 +1,15 @@
+module Rasti
+  module DB
+    module Relations
+      class OneToOne < OneToMany
+
+        private
+
+        def build_graph_result(rows)
+          rows.first
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

data/lib/rasti/db.rb

@@ -4,7 +4,12 @@ require 'consty'
 require_relative 'db/version'
 require_relative 'db/helpers'
 require_relative 'db/query'
-require_relative 'db/relations'
+require_relative 'db/relations/graph_builder'
+require_relative 'db/relations/base'
+require_relative 'db/relations/one_to_many'
+require_relative 'db/relations/one_to_one'
+require_relative 'db/relations/many_to_one'
+require_relative 'db/relations/many_to_many'
 require_relative 'db/collection'
 require_relative 'db/model'
 require_relative 'db/type_converter'

data/spec/collection_spec.rb

@@ -8,21 +8,14 @@ describe 'Collection' do
       Users.collection_name.must_equal :users
       Users.model.must_equal User
       Users.primary_key.must_equal :id
-      Users.implicit_foreign_key_name.must_equal :user_id
+      Users.foreign_key.must_equal :user_id
     end
 
     it 'Explicit' do
-      model_class = Rasti::DB::Model[:code, :name]
-      
-      collection_class = Class.new(Rasti::DB::Collection) do
-        set_collection_name :countries
-        set_primary_key :code
-        set_model model_class
-      end
-
-      collection_class.collection_name.must_equal :countries
-      collection_class.model.must_equal model_class
-      collection_class.primary_key.must_equal :code
+      People.collection_name.must_equal :people
+      People.model.must_equal Person
+      People.primary_key.must_equal :document_number
+      People.foreign_key.must_equal :document_number
     end
 
     it 'Lazy model name' do
@@ -165,6 +158,13 @@ describe 'Collection' do
       before :each do
         1.upto(3) do |i|
           user_id = db[:users].insert name: "User #{i}"
+
+          db[:people].insert document_number: "document_#{i}", 
+                             first_name: "John #{i}",
+                             last_name: "Doe #{i}",
+                             birth_date: Time.now - i,
+                             user_id: user_id
+
           category_id = db[:categories].insert name: "Category #{i}" 
           
           1.upto(3) do |n|
@@ -178,12 +178,6 @@ describe 'Collection' do
             db[:comments].insert post_id: post_id, user_id: user_id, text: 'Comment'
           end
         end
-
-        db[:users].count.must_equal 3
-        db[:categories].count.must_equal 3
-        db[:posts].count.must_equal 9
-        db[:categories_posts].count.must_equal 9
-        db[:comments].count.must_equal 9
       end
 
       it 'Self relations' do
@@ -206,6 +200,7 @@ describe 'Collection' do
 
       it 'Deep relations' do
         db[:users].where(id: 1).count.must_equal 1
+        db[:people].where(user_id: 1).count.must_equal 1
         db[:comments].where(user_id: 1).count.must_equal 3
         db[:posts].where(user_id: 1).count.must_equal 3
         db[:comments].join(:posts, id: :post_id).where(Sequel[:posts][:user_id] => 1).count.must_equal 3
@@ -214,12 +209,14 @@ describe 'Collection' do
         users.delete_cascade 1
 
         db[:users].where(id: 1).count.must_equal 0
+        db[:people].where(user_id: 1).count.must_equal 0
         db[:comments].where(user_id: 1).count.must_equal 0
         db[:posts].where(user_id: 1).count.must_equal 0
         db[:comments].join(:posts, id: :post_id).where(Sequel[:posts][:user_id] => 1).count.must_equal 0
         db[:categories_posts].join(:posts, id: :post_id).where(Sequel[:posts][:user_id] => 1).count.must_equal 0
         
         db[:users].count.must_equal 2
+        db[:people].count.must_equal 2
         db[:categories].count.must_equal 3
         db[:posts].count.must_equal 6
         db[:categories_posts].count.must_equal 6
@@ -312,12 +309,21 @@ describe 'Collection' do
     describe 'Named queries' do
 
       before do
-        1.upto(2) { |i| db[:categories].insert name: "Category #{i}" }
-        1.upto(2) { |i| db[:users].insert name: "User #{i}" }
+        1.upto(2) do |i|
+          db[:categories].insert name: "Category #{i}"
+          db[:users].insert name: "User #{i}"
+          db[:people].insert document_number: "document_#{i}", 
+                             first_name: "John #{i}",
+                             last_name: "Doe #{i}",
+                             birth_date: Time.now - i,
+                             user_id: i
+        end
+
         1.upto(3) do |i| 
           db[:posts].insert user_id: 1, title: "Post #{i}", body: '...'
           db[:categories_posts].insert category_id: 1, post_id: i
         end
+        
         4.upto(5) do |i| 
           db[:posts].insert user_id: 2, title: "Post #{i}", body: '...'
           db[:categories_posts].insert category_id: 2, post_id: i
@@ -338,6 +344,10 @@ describe 'Collection' do
           posts.with_users(2).primary_keys.must_equal [4,5]
         end
 
+        it 'One to One' do
+          users.with_people('document_1').primary_keys.must_equal [1]
+        end
+
       end
 
       it 'Global' do

data/spec/minitest_helper.rb

@@ -8,15 +8,17 @@ require 'sequel/extensions/pg_hstore'
 require 'sequel/extensions/pg_array'
 require 'sequel/extensions/pg_json'
 
-User     = Rasti::DB::Model[:id, :name, :posts, :comments]
+User     = Rasti::DB::Model[:id, :name, :posts, :comments, :person]
 Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories]
 Comment  = Rasti::DB::Model[:id, :text, :user_id, :user, :post_id, :post]
 Category = Rasti::DB::Model[:id, :name, :posts]
+Person   = Rasti::DB::Model[:document_number, :first_name, :last_name, :birth_date, :user_id, :user]
 
 
 class Users < Rasti::DB::Collection
   one_to_many :posts
   one_to_many :comments
+  one_to_one :person
 end
 
 class Posts < Rasti::DB::Collection
@@ -56,16 +58,23 @@ class Categories < Rasti::DB::Collection
   many_to_many :posts
 end
 
+class People < Rasti::DB::Collection
+  set_collection_name :people
+  set_primary_key :document_number
+  set_foreign_key :document_number
+  set_model Person
+
+  many_to_one :user
+end
+
 
 Rasti::DB::TypeConverter::CONVERTIONS[:sqlite] = {
-  /integer/ => ->(value, match) { value.to_i }
+  Regexp.new('integer') => ->(value, match) { value.to_i }
 }
 
 
 class Minitest::Spec
 
-  DB_DRIVER = (RUBY_ENGINE == 'jruby') ? 'jdbc:sqlite::memory:' : {adapter: :sqlite}
-
   let(:users) { Users.new db }
 
   let(:posts) { Posts.new db }
@@ -74,40 +83,52 @@ class Minitest::Spec
 
   let(:categories) { Categories.new db }
 
-  let :db do
-    db = Sequel.connect DB_DRIVER
-
-    db.create_table :users do
-      primary_key :id
-      String :name, null: false, unique: true
-    end
+  let(:people) { People.new db }
 
-    db.create_table :posts do
-      primary_key :id
-      String :title, null: false, unique: true
-      String :body, null: false
-      foreign_key :user_id, :users, null: false, index: true
-    end
-
-    db.create_table :comments do
-      primary_key :id
-      String :text, null: false
-      foreign_key :user_id, :users, null: false, index: true
-      foreign_key :post_id, :posts, null: false, index: true
-    end
-
-    db.create_table :categories do
-      primary_key :id
-      String :name, null: false, unique: true
-    end
+  let :db do
+    driver = (RUBY_ENGINE == 'jruby') ? 'jdbc:sqlite::memory:' : {adapter: :sqlite}
+
+    Sequel.connect(driver).tap do |db|
+
+      db.create_table :users do
+        primary_key :id
+        String :name, null: false, unique: true
+      end
+
+      db.create_table :posts do
+        primary_key :id
+        String :title, null: false, unique: true
+        String :body, null: false
+        foreign_key :user_id, :users, null: false, index: true
+      end
+
+      db.create_table :comments do
+        primary_key :id
+        String :text, null: false
+        foreign_key :user_id, :users, null: false, index: true
+        foreign_key :post_id, :posts, null: false, index: true
+      end
+
+      db.create_table :categories do
+        primary_key :id
+        String :name, null: false, unique: true
+      end
+
+      db.create_table :categories_posts do
+        foreign_key :category_id, :categories, null: false, index: true
+        foreign_key :post_id, :posts, null: false, index: true
+        primary_key [:category_id, :post_id]
+      end
+
+      db.create_table :people do
+        String :document_number, null: false, primary_key: true
+        String :first_name, null: false
+        String :last_name, null: false
+        Date :birth_date, null: false
+        foreign_key :user_id, :users, null: false, unique: true
+      end
 
-    db.create_table :categories_posts do
-      foreign_key :category_id, :categories, null: false, index: true
-      foreign_key :post_id, :posts, null: false, index: true
-      primary_key [:category_id, :post_id]
     end
-
-    db
   end
 
 end

data/spec/model_spec.rb

@@ -42,7 +42,7 @@ describe 'Model' do
   describe 'To String' do
     
     it 'Class' do
-      User.to_s.must_equal 'User[id, name, posts, comments]'
+      User.to_s.must_equal 'User[id, name, posts, comments, person]'
     end
 
     it 'Instance' do

data/spec/relations_spec.rb

@@ -29,6 +29,7 @@ describe 'Relations' do
       relation.one_to_many?.must_equal true
       relation.many_to_one?.must_equal false
       relation.many_to_many?.must_equal false
+      relation.one_to_one?.must_equal false
     end
 
     it 'Graph' do
@@ -70,6 +71,7 @@ describe 'Relations' do
       relation.one_to_many?.must_equal false
       relation.many_to_one?.must_equal true
       relation.many_to_many?.must_equal false
+      relation.one_to_one?.must_equal false
     end
 
     it 'Graph' do
@@ -117,6 +119,7 @@ describe 'Relations' do
       relation.one_to_many?.must_equal false
       relation.many_to_one?.must_equal false
       relation.many_to_many?.must_equal true
+      relation.one_to_one?.must_equal false
     end
 
     it 'Graph' do
@@ -141,4 +144,55 @@ describe 'Relations' do
 
   end
 
+  describe 'One To One' do
+
+    describe 'Specification' do
+
+      it 'Implicit' do
+        relation = Rasti::DB::Relations::OneToOne.new :person, Users
+        
+        relation.target_collection_class.must_equal People
+        relation.foreign_key.must_equal :user_id
+      end
+
+      it 'Explicit' do
+        relation = Rasti::DB::Relations::OneToOne.new :person, Users, collection: 'Users', 
+                                                                      foreign_key: :id_user
+        
+        relation.target_collection_class.must_equal Users
+        relation.foreign_key.must_equal :id_user
+      end
+
+    end
+
+    it 'Type' do
+      relation = Rasti::DB::Relations::OneToOne.new :person, User
+
+      relation.one_to_many?.must_equal false
+      relation.many_to_one?.must_equal false
+      relation.many_to_many?.must_equal false
+      relation.one_to_one?.must_equal true
+    end
+
+    it 'Graph' do
+      2.times do |i|
+        user_id = db[:users].insert name: "User #{i}"
+        db[:people].insert document_number: "document_#{i}", 
+                           first_name: "John #{i}",
+                           last_name: "Doe #{i}",
+                           birth_date: Time.now - i,
+                           user_id: user_id
+      end
+
+      rows = db[:users].all
+
+      Users.relations[:person].graph_to rows, db
+
+      2.times do |i|
+        rows[i][:person].must_equal people.find("document_#{i}")
+      end
+    end
+
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasti-db
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Gabriel Naiman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-06 00:00:00.000000000 Z
+date: 2017-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -192,7 +192,12 @@ files:
 - lib/rasti/db/helpers.rb
 - lib/rasti/db/model.rb
 - lib/rasti/db/query.rb
-- lib/rasti/db/relations.rb
+- lib/rasti/db/relations/base.rb
+- lib/rasti/db/relations/graph_builder.rb
+- lib/rasti/db/relations/many_to_many.rb
+- lib/rasti/db/relations/many_to_one.rb
+- lib/rasti/db/relations/one_to_many.rb
+- lib/rasti/db/relations/one_to_one.rb
 - lib/rasti/db/type_converter.rb
 - lib/rasti/db/version.rb
 - rasti-db.gemspec

data/lib/rasti/db/relations.rb

@@ -1,191 +0,0 @@
-module Rasti
-  module DB
-    module Relations
-
-      class << self
-
-        def graph_to(rows, relations, collection_class, db, schema=nil)
-          return if rows.empty?
-
-          parse(relations).each do |relation, nested_relations|
-            raise "Undefined relation #{relation} for #{collection_class}" unless collection_class.relations.key? relation
-            collection_class.relations[relation].graph_to rows, db, schema, nested_relations
-          end
-        end
-
-        private
-
-        def parse(relations)
-          relations.each_with_object({}) do |relation, hash|
-            tail = relation.to_s.split '.'
-            head = tail.shift.to_sym
-            hash[head] ||= []
-            hash[head] << tail.join('.') unless tail.empty?
-          end
-        end
-
-      end
-
-
-      class Base
-
-        include Sequel::Inflections
-
-        attr_reader :name, :source_collection_class
-
-        def initialize(name, source_collection_class, options={})
-          @name = name
-          @source_collection_class = source_collection_class
-          @options = options
-        end
-
-        def target_collection_class
-          @target_collection_class ||= @options[:collection].is_a?(Class) ? @options[:collection] : Consty.get(@options[:collection] || camelize(pluralize(name)), source_collection_class)
-        end
-
-        def qualified_source_collection_name(schema=nil)
-          schema.nil? ? source_collection_class.collection_name : Sequel.qualify(schema, source_collection_class.collection_name)
-        end
-
-        def qualified_target_collection_name(schema=nil)
-          schema.nil? ? target_collection_class.collection_name : Sequel.qualify(schema, target_collection_class.collection_name)
-        end
-
-        def one_to_many?
-          is_a? OneToMany
-        end
-
-        def many_to_one?
-          is_a? ManyToOne
-        end
-
-        def many_to_many?
-          is_a? ManyToMany
-        end
-
-        private
-
-        attr_reader :options
-
-      end
-      
-
-      class OneToMany < Base
-
-        def foreign_key
-          @foreign_key ||= @options[:foreign_key] || source_collection_class.implicit_foreign_key_name
-        end
-
-        def graph_to(rows, db, schema=nil, relations=[])
-          pks = rows.map { |row| row[source_collection_class.primary_key] }.uniq
-
-          target_collection = target_collection_class.new db, schema
-
-          relation_rows = target_collection.where(foreign_key => pks)
-                                           .graph(*relations)
-                                           .group_by { |r| r.public_send(foreign_key) }
-
-          rows.each do |row| 
-            row[name] = relation_rows.fetch row[source_collection_class.primary_key], []
-          end
-        end
-
-        def apply_filter(dataset, schema=nil, primary_keys=[])
-          target_name = qualified_target_collection_name schema
-
-          dataset.join(target_name, foreign_key => source_collection_class.primary_key)
-                 .where(Sequel.qualify(target_name, target_collection_class.primary_key) => primary_keys)
-                 .select_all(qualified_source_collection_name(schema))
-                 .distinct
-        end
-
-      end
-
-
-      class ManyToOne < Base
-
-        def foreign_key
-          @foreign_key ||= @options[:foreign_key] || target_collection_class.implicit_foreign_key_name
-        end
-
-        def graph_to(rows, db, schema=nil, relations=[])
-          fks = rows.map { |row| row[foreign_key] }.uniq
-
-          target_collection = target_collection_class.new db, schema
-
-          relation_rows = target_collection.where(source_collection_class.primary_key => fks)
-                                           .graph(*relations)
-                                           .each_with_object({}) do |row, hash| 
-                                              hash[row.public_send(source_collection_class.primary_key)] = row
-                                            end
-          
-          rows.each do |row| 
-            row[name] = relation_rows[row[foreign_key]]
-          end
-        end
-
-        def apply_filter(dataset, schema=nil, primary_keys=[])
-          dataset.where(foreign_key => primary_keys)
-        end
-
-      end
-
-
-      class ManyToMany < Base
-
-        def source_foreign_key
-          @source_foreign_key ||= @options[:source_foreign_key] || source_collection_class.implicit_foreign_key_name
-        end
-
-        def target_foreign_key
-          @target_foreign_key ||= @options[:target_foreign_key] || target_collection_class.implicit_foreign_key_name
-        end
-
-        def relation_collection_name
-          @relation_collection_name ||= @options[:relation_collection_name] || [source_collection_class.collection_name, target_collection_class.collection_name].sort.join('_').to_sym
-        end
-
-        def qualified_relation_collection_name(schema=nil)
-          schema.nil? ? relation_collection_name : Sequel.qualify(schema, relation_collection_name)
-        end
-
-        def graph_to(rows, db, schema=nil, relations=[])
-          pks = rows.map { |row| row[source_collection_class.primary_key] }
-
-          target_collection = target_collection_class.new db, schema
-
-          relation_name = qualified_relation_collection_name schema
-
-          join_rows = target_collection.dataset
-                                       .join(relation_name, target_foreign_key => target_collection_class.primary_key)
-                                       .where(Sequel.qualify(relation_name, source_foreign_key) => pks)
-                                       .select_all(qualified_target_collection_name(schema))
-                                       .select_append(Sequel.qualify(relation_name, source_foreign_key).as(:source_foreign_key))
-                                       .all
-
-          Relations.graph_to join_rows, relations, target_collection_class, db, schema
-
-          relation_rows = join_rows.each_with_object(Hash.new { |h,k| h[k] = [] }) do |row, hash| 
-            attributes = row.select { |attr,_| target_collection_class.model.attributes.include? attr }
-            hash[row[:source_foreign_key]] << target_collection_class.model.new(attributes)
-          end
-
-          rows.each do |row| 
-            row[name] = relation_rows.fetch row[target_collection_class.primary_key], []
-          end
-        end
-
-        def apply_filter(dataset, schema=nil, primary_keys=[])
-          relation_name = qualified_relation_collection_name schema
-
-          dataset.join(relation_name, source_foreign_key => target_collection_class.primary_key)
-                 .where(Sequel.qualify(relation_name, target_foreign_key) => primary_keys)
-                 .select_all(qualified_source_collection_name(schema))
-                 .distinct
-        end
-
-      end
-
-    end
-  end
-end