rasti-db 1.5.0 → 2.3.0

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

@@ -7,10 +7,10 @@ module Rasti
           @foreign_key ||= options[:foreign_key] || target_collection_class.foreign_key
         end
 
-        def fetch_graph(rows, db, schema=nil, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
+        def fetch_graph(environment, rows, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
           fks = rows.map { |row| row[foreign_key] }.uniq
 
-          target_collection = target_collection_class.new db, schema
+          target_collection = target_collection_class.new environment
 
           query = target_collection.where(source_collection_class.primary_key => fks)
           query = query.exclude_attributes(*excluded_attributes) if excluded_attributes
@@ -26,19 +26,21 @@ module Rasti
           end
         end
 
-        def add_join(dataset, schema=nil, prefix=nil)
+        def add_join(environment, dataset, prefix=nil)
+          validate_join!
+          
           relation_alias = join_relation_name prefix
 
-          qualified_relation_source = prefix ? Sequel[prefix] : qualified_source_collection_name(schema)
+          relation_name = prefix ? Sequel[prefix] : Sequel[source_collection_class.collection_name]
 
           relation_condition = {
-            Sequel[relation_alias][target_collection_class.primary_key] => qualified_relation_source[foreign_key]
+            Sequel[relation_alias][target_collection_class.primary_key] => relation_name[foreign_key]
           }
 
-          dataset.join(qualified_target_collection_name(schema).as(relation_alias), relation_condition)
+          dataset.join(environment.qualify_collection(target_collection_class).as(relation_alias), relation_condition)
         end
 
-        def apply_filter(dataset, schema=nil, primary_keys=[])
+        def apply_filter(environment, dataset, primary_keys)
           dataset.where(foreign_key => primary_keys)
         end
 

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

@@ -7,10 +7,10 @@ module Rasti
           @foreign_key ||= options[:foreign_key] || source_collection_class.foreign_key
         end
 
-        def fetch_graph(rows, db, schema=nil, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
+        def fetch_graph(environment, rows, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
           pks = rows.map { |row| row[source_collection_class.primary_key] }.uniq
 
-          target_collection = target_collection_class.new db, schema
+          target_collection = target_collection_class.new environment
 
           query = target_collection.where(foreign_key => pks)
           query = query.exclude_attributes(*excluded_attributes) if excluded_attributes
@@ -24,25 +24,33 @@ module Rasti
           end
         end
 
-        def add_join(dataset, schema=nil, prefix=nil)
+        def add_join(environment, dataset, prefix=nil)
+          validate_join!
+          
           relation_alias = join_relation_name prefix
 
-          qualified_relation_source = prefix ? Sequel[prefix] : qualified_source_collection_name(schema)
+          relation_name = prefix ? Sequel[prefix] : Sequel[source_collection_class.collection_name]
 
           relation_condition = {
-            Sequel[relation_alias][foreign_key] => qualified_relation_source[source_collection_class.primary_key]
+            Sequel[relation_alias][foreign_key] => relation_name[source_collection_class.primary_key]
           }
 
-          dataset.join(qualified_target_collection_name(schema).as(relation_alias), relation_condition)
+          dataset.join(environment.qualify_collection(target_collection_class).as(relation_alias), relation_condition)
         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[target_name][target_collection_class.primary_key] => primary_keys)
-                 .select_all(qualified_source_collection_name(schema))
-                 .distinct
+        def apply_filter(environment, dataset, primary_keys)
+          if source_collection_class.data_source_name == target_collection_class.data_source_name
+            dataset.join(environment.qualify_collection(target_collection_class), foreign_key => source_collection_class.primary_key)
+                   .where(Sequel[target_collection_class.collection_name][target_collection_class.primary_key] => primary_keys)
+                   .select_all(target_collection_class.collection_name)
+                   .distinct
+          else
+            target_collection = target_collection_class.new environment
+            fks = target_collection.where(target_collection_class.primary_key => primary_keys)
+                                   .pluck(foreign_key)
+                                   .uniq
+            dataset.where(source_collection_class.primary_key => fks)
+          end
         end
 
         private

data/lib/rasti/db/type_converters/sqlite.rb

@@ -0,0 +1,62 @@
+module Rasti
+  module DB
+    module TypeConverters
+      class SQLite
+
+        CONVERTERS = [SQLiteTypes::Array]
+
+        @to_db_mapping = {}
+
+        class << self
+
+          def to_db(db, collection_name, attribute_name, value)
+            to_db_mapping = to_db_mapping_for db, collection_name
+
+            if to_db_mapping.key? attribute_name
+              to_db_mapping[attribute_name][:converter].to_db value
+            else
+              value
+            end
+          end
+
+          def from_db(object)
+            converter = find_converter_from_db object
+            if !converter.nil?
+              converter.from_db object
+            else
+              object
+            end
+          end
+
+          private
+
+          def to_db_mapping_for(db, collection_name)
+            key = [db.opts[:database], collection_name]
+
+            @to_db_mapping[key] ||= begin
+              columns = Hash[db.schema(collection_name)]
+
+              columns.each_with_object({}) do |(name, schema), hash|
+                CONVERTERS.each do |converter|
+                  unless hash.key? name
+                    match = converter.column_type_regex.match schema[:db_type]
+
+                    hash[name] = { converter: converter } if match
+                  end
+                end
+              end
+            end
+          end
+
+          def find_converter_from_db(object)
+            CONVERTERS.find do |converter|
+              converter.respond_for? object
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/type_converters/sqlite_types/array.rb

@@ -0,0 +1,34 @@
+module Rasti
+  module DB
+    module TypeConverters
+      module SQLiteTypes
+        class Array
+
+          class << self
+
+            def column_type_regex
+              /^([a-z]+)\[\]$/
+            end
+
+            def to_db(values)
+              JSON.dump(values)
+            end
+
+            def respond_for?(object)
+              parsed = JSON.parse object
+              object == to_db(parsed)
+            rescue
+              false
+            end
+
+            def from_db(object)
+              JSON.parse object
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '1.5.0'
+    VERSION = '2.3.0'
   end
 end

data/rasti-db.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'multi_require', '~> 1.0'
   spec.add_runtime_dependency 'hierarchical_graph', '~> 1.0'
   spec.add_runtime_dependency 'hash_ext', '~> 0.5'
+  spec.add_runtime_dependency 'inflecto', '~> 0.0'
 
   spec.add_development_dependency 'rake', '~> 12.3'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'

data/spec/collection_spec.rb

@@ -2,6 +2,14 @@ require 'minitest_helper'
 
 describe 'Collection' do
 
+  before do
+    Rasti::DB.type_converters = [Rasti::DB::TypeConverters::TimeInZone]
+  end
+
+  after do
+    Rasti::DB.type_converters = [Rasti::DB::TypeConverters::TimeInZone, Rasti::DB::TypeConverters::SQLite]
+  end
+
   describe 'Specification' do
 
     it 'Implicit' do
@@ -10,6 +18,7 @@ describe 'Collection' do
       Users.model.must_equal User
       Users.primary_key.must_equal :id
       Users.foreign_key.must_equal :user_id
+      Users.data_source_name.must_equal :default
     end
 
     it 'Explicit' do
@@ -18,6 +27,8 @@ describe 'Collection' do
       People.model.must_equal Person
       People.primary_key.must_equal :document_number
       People.foreign_key.must_equal :document_number
+
+      Languages.data_source_name.must_equal :custom
     end
 
     it 'Lazy model name' do
@@ -42,11 +53,11 @@ describe 'Collection' do
       user_id = db[:users].insert name: 'User 1'
 
       1.upto(2) do |i| 
-        db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...'
+        db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...', language_id: 1
         db[:categories].insert name: "Category #{i}"
       end
 
-      post_id = posts.insert user_id: user_id, title: 'Post title', body: '...', categories: [1,2]
+      post_id = posts.insert user_id: user_id, title: 'Post title', body: '...', categories: [1,2], language_id: 1
       category_id = categories.insert name: 'Category', posts: [1,2]
 
       db[:categories_posts].where(post_id: post_id).map(:category_id).must_equal [1,2]
@@ -59,7 +70,7 @@ describe 'Collection' do
       end
 
       user_id = db[:users].insert name: 'User 1'
-      post_id = db[:posts].insert user_id: user_id, title: 'Post title', body: '...'
+      post_id = db[:posts].insert user_id: user_id, title: 'Post title', body: '...', language_id: 1
       1.upto(2) { |category_id| db[:categories_posts].insert post_id: post_id, category_id: category_id }
 
       posts.insert_relations post_id, categories: [3]
@@ -91,7 +102,7 @@ describe 'Collection' do
       user_id = db[:users].insert name: 'User 1'
 
       1.upto(3) do |i| 
-        db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...'
+        db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...', language_id: 1
         db[:categories].insert name: "Category #{i}"
       end
 
@@ -114,7 +125,7 @@ describe 'Collection' do
 
     it 'Bulk update' do
       user_id = db[:users].insert name: 'User 1'
-      1.upto(3) { |i| db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...' }
+      1.upto(3) { |i| db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...', language_id: 1 }
 
       posts.bulk_update(body: 'Updated ...') { where id: [1,2] }
 
@@ -139,7 +150,7 @@ describe 'Collection' do
       end
 
       user_id = db[:users].insert name: 'User 1'
-      post_id = db[:posts].insert user_id: user_id, title: 'Post title', body: '...'
+      post_id = db[:posts].insert user_id: user_id, title: 'Post title', body: '...', language_id: 1
       1.upto(3) { |category_id| db[:categories_posts].insert post_id: post_id, category_id: category_id }
 
       posts.delete_relations post_id, categories: [3]
@@ -170,7 +181,7 @@ describe 'Collection' do
           category_id = db[:categories].insert name: "Category #{i}" 
           
           1.upto(3) do |n|
-            post_id = db[:posts].insert user_id: user_id, title: "Post #{i}.#{n}", body: '...'
+            post_id = db[:posts].insert user_id: user_id, title: "Post #{i}.#{n}", body: '...', language_id: 1
             db[:categories_posts].insert post_id: post_id, category_id: category_id
           end
         end
@@ -227,6 +238,65 @@ describe 'Collection' do
 
     end
 
+    describe 'Multiple data sources' do
+
+      before do
+        1.upto(3) do |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
+      end
+
+      it 'Insert' do
+        id = languages.insert name: 'Spanish', people: ['document_1', 'document_2']
+
+        custom_db[:languages][id: id][:name].must_equal 'Spanish'
+        db[:languages_people].where(language_id: id).select_map(:document_number).must_equal ['document_1', 'document_2']
+      end
+
+      it 'Update' do
+        id = custom_db[:languages].insert name: 'Spanish'
+        db[:languages_people].insert language_id: id, document_number: 'document_1'
+
+        custom_db[:languages][id: id][:name].must_equal 'Spanish'
+        db[:languages_people].where(language_id: id).select_map(:document_number).must_equal ['document_1']
+
+        languages.update id, name: 'English', people: ['document_2', 'document_3']
+
+        custom_db[:languages][id: id][:name].must_equal 'English'
+        db[:languages_people].where(language_id: id).select_map(:document_number).must_equal ['document_2', 'document_3']
+      end
+
+      it 'Delete' do
+        id = custom_db[:languages].insert name: 'Spanish'
+        db[:languages_people].insert language_id: id, document_number: 'document_1'
+        db[:posts].insert user_id: 1, title: 'Post 1', body: '...', language_id: id
+
+        languages.delete id
+
+        custom_db[:languages].count.must_equal 0
+        db[:languages_people].where(language_id: id).count.must_equal 1
+        db[:posts].where(language_id: id).count.must_equal 1
+      end
+
+      it 'Delete cascade' do
+        id = custom_db[:languages].insert name: 'Spanish'
+        db[:languages_people].insert language_id: id, document_number: 'document_1'
+        db[:posts].insert user_id: 1, title: 'Post 1', body: '...', language_id: id
+
+        languages.delete_cascade id
+
+        custom_db[:languages].count.must_equal 0
+        db[:languages_people].where(language_id: id).count.must_equal 0
+        db[:posts].where(language_id: id).count.must_equal 0
+      end
+
+    end
+
   end
 
   describe 'Queries' do
@@ -239,7 +309,7 @@ describe 'Collection' do
 
     it 'Find graph' do
       user_id = db[:users].insert name: 'User 1'
-      db[:posts].insert user_id: user_id, title: 'Post 1', body: '...'
+      db[:posts].insert user_id: user_id, title: 'Post 1', body: '...', language_id: 1
 
       users.find_graph(user_id, :posts).must_equal User.new id: user_id, name: 'User 1', posts: posts.all
     end
@@ -316,42 +386,51 @@ describe 'Collection' do
 
     it 'Chain dataset as query' do
       1.upto(2) { |i| db[:users].insert name: "User #{i}" }
-      1.upto(3) { |i| db[:posts].insert user_id: 1, title: "Post #{i}", body: '...' }
+      1.upto(3) { |i| db[:posts].insert user_id: 1, title: "Post #{i}", body: '...', language_id: 1 }
       1.upto(2) { |i| db[:comments].insert post_id: i, user_id: 2, text: 'Comment' }
 
       models = posts.commented_by(2).all
-      models.must_equal [1,2].map { |i| Post.new(id: i, user_id: 1, title: "Post #{i}", body: '...') }
+      models.must_equal [1,2].map { |i| Post.new(id: i, user_id: 1, title: "Post #{i}", body: '...', language_id: 1) }
     end
 
     it 'Custom query' do
       1.upto(2) { |i| db[:users].insert name: "User #{i}" }
-      1.upto(3) { |i| db[:posts].insert user_id: 1, title: "Post #{i}", body: '...' }
+      1.upto(3) { |i| db[:posts].insert user_id: 1, title: "Post #{i}", body: '...', language_id: 1 }
       1.upto(2) { |i| db[:comments].insert post_id: i, user_id: 2, text: 'Comment' }
 
       models = comments.posts_commented_by(2)
-      models.must_equal [1,2].map { |i| Post.new(id: i, user_id: 1, title: "Post #{i}", body: '...') }
+      models.must_equal [1,2].map { |i| Post.new(id: i, user_id: 1, title: "Post #{i}", body: '...', language_id: 1) }
     end
 
     describe 'Named queries' do
 
       before do
+        custom_db[:languages].insert name: 'Spanish'
+        custom_db[:languages].insert name: 'English'
+
         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
 
+        db[:languages_people].insert language_id: 1, document_number: 'document_1'
+        db[:languages_people].insert language_id: 2, document_number: 'document_2'
+
         1.upto(3) do |i| 
-          db[:posts].insert user_id: 1, title: "Post #{i}", body: '...'
+          db[:posts].insert user_id: 1, title: "Post #{i}", body: '...', language_id: 1
           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[:posts].insert user_id: 2, title: "Post #{i}", body: '...', language_id: 2
           db[:categories_posts].insert category_id: 2, post_id: i
         end
       end
@@ -374,6 +453,23 @@ describe 'Collection' do
           users.with_people('document_1').primary_keys.must_equal [1]
         end
 
+        describe 'Multiple data sources' do
+
+          it 'One to many' do
+            languages.with_posts([1,2]).primary_keys.must_equal [1]
+          end
+
+          it 'Many to one' do
+            posts.with_languages([2]).primary_keys.must_equal [4,5]
+          end
+
+          it 'Many to Many' do
+            languages.with_people(['document_1']).primary_keys.must_equal [1]
+            people.with_languages([2]).primary_keys.must_equal ['document_2']
+          end
+
+        end
+
       end
 
       it 'Global' do
@@ -400,7 +496,7 @@ describe 'Collection' do
                            birth_date: Time.now - i,
                            user_id: i
         db[:categories].insert name: "Category #{i}"
-        db[:posts].insert user_id: i, title: "Post #{i}", body: '...'
+        db[:posts].insert user_id: i, title: "Post #{i}", body: '...', language_id: 1
         db[:categories_posts].insert post_id: i, category_id: i
       end
 
@@ -448,21 +544,21 @@ describe 'Collection' do
       stubs = Proc.new do |sql|
         case sql
 
-        when 'SELECT users.* FROM custom_schema.users', 
-             'SELECT users.* FROM custom_schema.users WHERE (id IN (2, 1))'
+        when 'SELECT users.* FROM schema_1.users', 
+             'SELECT users.* FROM schema_1.users WHERE (users.id IN (2, 1))'
           [
             {id: 1},
             {id: 2}
           ]
 
-        when 'SELECT posts.* FROM custom_schema.posts',
-             'SELECT posts.* FROM custom_schema.posts WHERE (user_id IN (1, 2))'
+        when 'SELECT posts.* FROM schema_1.posts',
+             'SELECT posts.* FROM schema_1.posts WHERE (posts.user_id IN (1, 2))'
           [
-            {id: 3, user_id: 1},
-            {id: 4, user_id: 2}
+            {id: 3, user_id: 1, language_id: 1},
+            {id: 4, user_id: 2, language_id: 2}
           ]
 
-        when 'SELECT comments.* FROM custom_schema.comments WHERE (post_id IN (3, 4))'
+        when 'SELECT comments.* FROM schema_1.comments WHERE (comments.post_id IN (3, 4))'
           [
             {id: 5, user_id: 2, post_id: 3},
             {id: 6, user_id: 1, post_id: 3},
@@ -470,88 +566,152 @@ describe 'Collection' do
             {id: 8, user_id: 2, post_id: 4}
           ]
 
-        else
-          nil
+        when 'SELECT languages.* FROM schema_2.languages WHERE (languages.id IN (1, 2))'
+          [
+            {id: 1},
+            {id: 2}
+          ]
+
         end
       end
 
-      Sequel.mock(fetch: stubs, autoid: 1).tap do |mock|
-        get_schema_block = ->(table_name) { db.schema table_name }
-        mock.define_singleton_method(:schema_parse_table) do |table_name, opts| 
-          get_schema_block.call table_name
+      last_id = 0
+      autoid = Proc.new do |sql|
+        case sql
+        when "INSERT INTO schema_1.people (document_number, first_name, last_name, birth_date, user_id) VALUES ('document_1', 'John', 'Doe', '2020-04-24 00:00:00.000000', 1)"
+          'document_1'
+        else
+          last_id += 1
         end
       end
+
+      Sequel.mock fetch: stubs, autoid: autoid
     end
 
-    let(:stub_users)    { Users.new    stub_db, :custom_schema }
-    let(:stub_posts)    { Posts.new    stub_db, :custom_schema }
-    let(:stub_comments) { Comments.new stub_db, :custom_schema }
+    let :stub_environment do 
+      Rasti::DB::Environment.new default: Rasti::DB::DataSource.new(stub_db, :schema_1),
+                                 custom: Rasti::DB::DataSource.new(stub_db, :schema_2)
+    end
+
+    let(:stub_users)     { Users.new stub_environment }
+    let(:stub_posts)     { Posts.new stub_environment }
+    let(:stub_comments)  { Comments.new stub_environment }
+    let(:stub_people)    { People.new stub_environment }
+    let(:stub_languages) { Languages.new stub_environment }
 
     it 'Insert' do
       stub_users.insert name: 'User 1'
+
       stub_db.sqls.must_equal [
         'BEGIN',
-        "INSERT INTO custom_schema.users (name) VALUES ('User 1')",
+        "INSERT INTO schema_1.users (name) VALUES ('User 1')",
         'COMMIT'
       ]
     end
 
     it 'Insert with many to many relation' do
-      stub_posts.insert user_id: 1, title: 'Post 1', body: '...', categories: [2,3]
+      stub_posts.insert user_id: 1, title: 'Post 1', body: '...', categories: [2,3], language_id: 1
+
+      stub_db.sqls.must_equal [
+        'BEGIN',
+        "INSERT INTO schema_1.posts (user_id, title, body, language_id) VALUES (1, 'Post 1', '...', 1)",
+        'DELETE FROM schema_1.categories_posts WHERE (post_id IN (1))',
+        'INSERT INTO schema_1.categories_posts (post_id, category_id) VALUES (1, 2)',
+        'INSERT INTO schema_1.categories_posts (post_id, category_id) VALUES (1, 3)',
+        'COMMIT'
+      ]
+    end
+
+    it 'Insert in multiple schemas' do
+      stub_languages.insert name: 'Spanish'
+
+      stub_users.insert name: 'User 1'
+
+      stub_people.insert document_number: 'document_1', 
+                         first_name: 'John',
+                         last_name: 'Doe',
+                         birth_date: Time.parse('2020-04-24'),
+                         user_id: 1,
+                         languages: [1]
+
       stub_db.sqls.must_equal [
         'BEGIN',
-        "INSERT INTO custom_schema.posts (user_id, title, body) VALUES (1, 'Post 1', '...')",
-        'DELETE FROM custom_schema.categories_posts WHERE (post_id IN (1))',
-        'INSERT INTO custom_schema.categories_posts (post_id, category_id) VALUES (1, 2)',
-        'INSERT INTO custom_schema.categories_posts (post_id, category_id) VALUES (1, 3)',
+        "INSERT INTO schema_2.languages (name) VALUES ('Spanish')",
+        'COMMIT',
+        'BEGIN',
+        "INSERT INTO schema_1.users (name) VALUES ('User 1')",
+        'COMMIT',
+        'BEGIN',
+        "INSERT INTO schema_1.people (document_number, first_name, last_name, birth_date, user_id) VALUES ('document_1', 'John', 'Doe', '2020-04-24 00:00:00.000000', 1)",
+        "DELETE FROM schema_1.languages_people WHERE (document_number IN ('document_1'))",
+        "INSERT INTO schema_1.languages_people (document_number, language_id) VALUES ('document_1', 1)",
         'COMMIT'
       ]
     end
 
     it 'Update' do
       stub_users.update 1, name: 'Updated name'
+
       stub_db.sqls.must_equal [
         'BEGIN',
-        "UPDATE custom_schema.users SET name = 'Updated name' WHERE (id = 1)",
+        "UPDATE schema_1.users SET name = 'Updated name' WHERE (id = 1)",
         'COMMIT'
       ]
     end
 
     it 'Delete' do
       stub_users.delete 1
-      stub_db.sqls.must_equal ['DELETE FROM custom_schema.users WHERE (id = 1)']
+
+      stub_db.sqls.must_equal [
+        'DELETE FROM schema_1.users WHERE (id = 1)'
+      ]
     end
 
     it 'Chained query' do
       stub_users.where(id: [1,2]).limit(1).order(:name).all
-      stub_db.sqls.must_equal ['SELECT users.* FROM custom_schema.users WHERE (id IN (1, 2)) ORDER BY name LIMIT 1']
+
+      stub_db.sqls.must_equal [
+        'SELECT users.* FROM schema_1.users WHERE (users.id IN (1, 2)) ORDER BY users.name LIMIT 1'
+      ]
     end
 
     it 'Graph' do
-      stub_posts.graph(:user, :categories, 'comments.user.posts.categories').all
+      stub_posts.graph(:user, :categories, 'comments.user.posts.categories', 'language.people').all
 
       stub_db.sqls.must_equal [
-        'SELECT posts.* FROM custom_schema.posts',
-        'SELECT categories.*, custom_schema.categories_posts.post_id AS source_foreign_key FROM custom_schema.categories INNER JOIN custom_schema.categories_posts ON (custom_schema.categories_posts.category_id = custom_schema.categories.id) WHERE (custom_schema.categories_posts.post_id IN (3, 4))', 
-        'SELECT comments.* FROM custom_schema.comments WHERE (post_id IN (3, 4))',
-        'SELECT users.* FROM custom_schema.users WHERE (id IN (2, 1))',
-        'SELECT posts.* FROM custom_schema.posts WHERE (user_id IN (1, 2))',
-        'SELECT categories.*, custom_schema.categories_posts.post_id AS source_foreign_key FROM custom_schema.categories INNER JOIN custom_schema.categories_posts ON (custom_schema.categories_posts.category_id = custom_schema.categories.id) WHERE (custom_schema.categories_posts.post_id IN (3, 4))',
-        'SELECT users.* FROM custom_schema.users WHERE (id IN (1, 2))'
+        'SELECT posts.* FROM schema_1.posts',
+        'SELECT categories.*, categories_posts.post_id AS source_foreign_key FROM schema_1.categories INNER JOIN schema_1.categories_posts ON (schema_1.categories_posts.category_id = schema_1.categories.id) WHERE (categories_posts.post_id IN (3, 4))', 
+        'SELECT comments.* FROM schema_1.comments WHERE (comments.post_id IN (3, 4))',
+        'SELECT users.* FROM schema_1.users WHERE (users.id IN (2, 1))',
+        'SELECT posts.* FROM schema_1.posts WHERE (posts.user_id IN (1, 2))',
+        'SELECT categories.*, categories_posts.post_id AS source_foreign_key FROM schema_1.categories INNER JOIN schema_1.categories_posts ON (schema_1.categories_posts.category_id = schema_1.categories.id) WHERE (categories_posts.post_id IN (3, 4))',
+        'SELECT languages.* FROM schema_2.languages WHERE (languages.id IN (1, 2))',
+        'SELECT people.*, languages_people.language_id AS source_foreign_key FROM schema_1.people INNER JOIN schema_1.languages_people ON (schema_1.languages_people.document_number = schema_1.people.document_number) WHERE (languages_people.language_id IN (1, 2))',
+        'SELECT users.* FROM schema_1.users WHERE (users.id IN (1, 2))'
+      ]
+    end
+
+    it 'Join' do
+      stub_posts.join('user.person').where(document_number: 'document_1').all
+
+      stub_db.sqls.must_equal [
+        "SELECT DISTINCT posts.* FROM schema_1.posts INNER JOIN schema_1.users AS user ON (user.id = posts.user_id) INNER JOIN schema_1.people AS user__person ON (user__person.user_id = user.id) WHERE (posts.document_number = 'document_1')"
       ]
     end
 
     it 'Named query' do
       stub_posts.commented_by(1).all
+
       stub_db.sqls.must_equal [
-        'SELECT DISTINCT posts.* FROM custom_schema.posts INNER JOIN custom_schema.comments ON (custom_schema.comments.post_id = custom_schema.posts.id) WHERE (custom_schema.comments.user_id = 1)'
+        'SELECT DISTINCT posts.* FROM schema_1.posts INNER JOIN schema_1.comments ON (schema_1.comments.post_id = schema_1.posts.id) WHERE (comments.user_id = 1)'
       ]
     end
 
     it 'Custom query' do
       stub_comments.posts_commented_by(2)
+
       stub_db.sqls.must_equal [
-        'SELECT posts.* FROM custom_schema.comments INNER JOIN custom_schema.posts ON (custom_schema.posts.id = custom_schema.comments.post_id) WHERE (comments.user_id = 2)'
+        'SELECT posts.* FROM schema_1.comments INNER JOIN schema_1.posts ON (schema_1.posts.id = schema_1.comments.post_id) WHERE (comments.user_id = 2)'
       ]
     end