rasti-db 1.4.0 → 2.2.0

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

@@ -15,25 +15,44 @@ module Rasti
           @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? ? Sequel[relation_collection_name] : Sequel[schema][relation_collection_name]
+        def relation_data_source_name
+          @relation_data_source_name ||= options[:relation_data_source_name] || source_collection_class.data_source_name
         end
 
-        def graph_to(rows, db, schema=nil, relations=[])
+        def fetch_graph(environment, rows, selected_attributes=nil, excluded_attributes=nil, relations_graph=nil)
           pks = rows.map { |row| row[source_collection_class.primary_key] }
 
-          target_collection = target_collection_class.new db, schema
+          if target_collection_class.data_source_name == relation_data_source_name
+            target_data_source = environment.data_source_of target_collection_class
 
-          relation_name = qualified_relation_collection_name schema
+            dataset = target_data_source.db.from(environment.qualify_collection(target_collection_class))
+                                           .join(qualified_relation_collection_name(environment), target_foreign_key => target_collection_class.primary_key)
+                                           .where(Sequel[relation_collection_name][source_foreign_key] => pks)
+                                           .select_all(target_collection_class.collection_name)
 
-          join_rows = target_collection.dataset
-                                       .join(relation_name, target_foreign_key => target_collection_class.primary_key)
-                                       .where(Sequel[relation_name][source_foreign_key] => pks)
-                                       .select_all(qualified_target_collection_name(schema))
-                                       .select_append(Sequel[relation_name][source_foreign_key].as(:source_foreign_key))
-                                       .all
+            selected_attributes ||= target_collection_class.collection_attributes - excluded_attributes if excluded_attributes
+            dataset = dataset.select(*selected_attributes.map { |a| Sequel[target_collection_class.collection_name][a] }) if selected_attributes
 
-          GraphBuilder.graph_to join_rows, relations, target_collection_class, db, schema
+            join_rows = dataset.select_append(Sequel[relation_collection_name][source_foreign_key].as(:source_foreign_key)).all
+          else
+            relation_data_source = environment.data_source relation_data_source_name
+
+            relation_index = relation_data_source.db.from(relation_data_source.qualify(relation_collection_name))
+                                                    .where(source_foreign_key => pks)
+                                                    .select_hash_groups(target_foreign_key, source_foreign_key)
+
+            query = target_collection_class.new environment
+            query = query.exclude_attributes(*excluded_attributes) if excluded_attributes
+            query = query.select_attributes(*selected_attributes) if selected_attributes
+
+            join_rows = query.where(target_collection_class.primary_key => relation_index.keys).raw.flat_map do |row|
+              relation_index[row[target_collection_class.primary_key]].map do |source_primary_key|
+                row.merge(source_foreign_key: source_primary_key)
+              end
+            end
+          end
+
+          relations_graph.fetch_graph join_rows if relations_graph
 
           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 }
@@ -41,17 +60,19 @@ module Rasti
           end
 
           rows.each do |row| 
-            row[name] = relation_rows.fetch row[target_collection_class.primary_key], []
+            row[name] = relation_rows.fetch row[source_collection_class.primary_key], []
           end
         end
 
-        def join_to(dataset, schema=nil, prefix=nil)
+        def add_join(environment, dataset, prefix=nil)
+          validate_join!
+          
           many_to_many_relation_alias = with_prefix prefix, "#{relation_collection_name}_#{SecureRandom.base64}"
 
-          qualified_relation_source = prefix ? Sequel[prefix] : qualified_source_collection_name(schema)
+          relation_name = prefix ? Sequel[prefix] : Sequel[source_collection_class.collection_name]
 
           many_to_many_condition = {
-            Sequel[many_to_many_relation_alias][source_foreign_key] => qualified_relation_source[source_collection_class.primary_key]
+            Sequel[many_to_many_relation_alias][source_foreign_key] => relation_name[source_collection_class.primary_key]
           }
 
           relation_alias = join_relation_name prefix
@@ -60,17 +81,30 @@ module Rasti
             Sequel[relation_alias][target_collection_class.primary_key] => Sequel[many_to_many_relation_alias][target_foreign_key]
           }
 
-          dataset.join(qualified_relation_collection_name(schema).as(many_to_many_relation_alias), many_to_many_condition)
-                 .join(qualified_target_collection_name(schema).as(relation_alias), relation_condition)
+          dataset.join(qualified_relation_collection_name(environment).as(many_to_many_relation_alias), many_to_many_condition)
+                 .join(environment.qualify_collection(target_collection_class).as(relation_alias), relation_condition)
+        end
+
+        def apply_filter(environment, dataset, primary_keys)
+          if source_collection_class.data_source_name == relation_data_source_name
+            dataset.join(qualified_relation_collection_name(environment), source_foreign_key => source_collection_class.primary_key)
+                   .where(Sequel[relation_collection_name][target_foreign_key] => primary_keys)
+                   .select_all(source_collection_class.collection_name)
+                   .distinct
+          else
+            data_source = environment.data_source relation_data_source_name
+            fks = data_source.db.from(data_source.qualify(relation_collection_name))
+                                .where(target_collection_class.foreign_key => primary_keys)
+                                .select_map(source_collection_class.foreign_key)
+                                .uniq
+            dataset.where(source_collection_class.primary_key => fks)
+          end
         end
 
-        def apply_filter(dataset, schema=nil, primary_keys=[])
-          relation_name = qualified_relation_collection_name schema
+        private
 
-          dataset.join(relation_name, source_foreign_key => target_collection_class.primary_key)
-                 .where(Sequel[relation_name][target_foreign_key] => primary_keys)
-                 .select_all(qualified_source_collection_name(schema))
-                 .distinct
+        def qualified_relation_collection_name(environment)
+          environment.qualify relation_data_source_name, relation_collection_name
         end
 
       end

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

@@ -7,35 +7,40 @@ module Rasti
           @foreign_key ||= options[:foreign_key] || target_collection_class.foreign_key
         end
 
-        def graph_to(rows, db, schema=nil, relations=[])
+        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
 
-          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
+          query = target_collection.where(source_collection_class.primary_key => fks)
+          query = query.exclude_attributes(*excluded_attributes) if excluded_attributes
+          query = query.select_attributes(*selected_attributes) if selected_attributes
+          query = relations_graph.apply_to query if relations_graph
+
+          relation_rows = query.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 join_to(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,39 +7,50 @@ module Rasti
           @foreign_key ||= options[:foreign_key] || source_collection_class.foreign_key
         end
 
-        def graph_to(rows, db, schema=nil, relations=[])
+        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
 
-          relation_rows = target_collection.where(foreign_key => pks)
-                                           .graph(*relations)
-                                           .group_by { |r| r.public_send(foreign_key) }
+          query = target_collection.where(foreign_key => pks)
+          query = query.exclude_attributes(*excluded_attributes) if excluded_attributes
+          query = query.select_attributes(*selected_attributes) if selected_attributes
+          query = relations_graph.apply_to query if relations_graph
+
+          relation_rows = query.group_by(&foreign_key)
 
           rows.each do |row| 
             row[name] = build_graph_result relation_rows.fetch(row[source_collection_class.primary_key], [])
           end
         end
 
-        def join_to(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/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '1.4.0'
+    VERSION = '2.2.0'
   end
 end

data/rasti-db.gemspec

@@ -24,8 +24,10 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'timing', '~> 0.1', '>= 0.1.3'
   spec.add_runtime_dependency 'class_config', '~> 0.0', '>= 0.0.2'
   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_development_dependency 'rake', '~> 11.0'
+  spec.add_development_dependency 'rake', '~> 12.3'
   spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'
   spec.add_development_dependency 'minitest-colorin', '~> 0.1'
   spec.add_development_dependency 'minitest-line', '~> 0.6'
@@ -38,10 +40,4 @@ Gem::Specification.new do |spec|
   else
     spec.add_development_dependency 'sqlite3', '~> 1.3'
   end
-
-  if RUBY_VERSION < '2'
-    spec.add_development_dependency 'term-ansicolor', '~> 1.3.0'
-    spec.add_development_dependency 'tins', '~> 1.6.0'
-    spec.add_development_dependency 'json', '~> 1.8'
-  end
 end

data/spec/collection_spec.rb

@@ -6,18 +6,21 @@ describe 'Collection' do
 
     it 'Implicit' do
       Users.collection_name.must_equal :users
-      Users.collection_fields.must_equal [:id, :name]
+      Users.collection_attributes.must_equal [:id, :name]
       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
       People.collection_name.must_equal :people
-      People.collection_fields.must_equal [:document_number, :first_name, :last_name, :birth_date, :user_id]
+      People.collection_attributes.must_equal [:document_number, :first_name, :last_name, :birth_date, :user_id]
       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 +45,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 +62,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 +94,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 +117,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 +142,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 +173,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 +230,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,11 +301,29 @@ 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
 
+    it 'Select attributes' do
+      id = db[:users].insert name: 'User 1'
+
+      users.select_attributes(:id).all.must_equal [User.new(id: id)]
+    end
+
+    it 'Exclude attributes' do
+      db[:users].insert name: 'User 1'
+
+      users.exclude_attributes(:id).all.must_equal [User.new(name: 'User 1')]
+    end
+
+    it 'All attributes' do
+      id = db[:users].insert name: 'User 1'
+
+      users.select_attributes(:id).all_attributes.all.must_equal [User.new(id: id, name: 'User 1')]
+    end
+
     it 'Count' do
       1.upto(10) { |i| db[:users].insert name: "User #{i}" }
 
@@ -298,42 +378,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
@@ -356,6 +445,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
@@ -382,7 +488,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
 
@@ -430,21 +536,21 @@ describe 'Collection' do
       stubs = Proc.new do |sql|
         case sql
 
-        when 'SELECT * FROM custom_schema.users', 
-             'SELECT * 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 * FROM custom_schema.posts',
-             'SELECT * 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 * 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},
@@ -452,87 +558,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_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_db, :custom_schema }
-    let(:stub_posts)    { Posts.new    stub_db, :custom_schema }
-    let(:stub_comments) { Comments.new stub_db, :custom_schema }
+    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 * 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 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 * FROM custom_schema.posts',
-        'SELECT * FROM custom_schema.users WHERE (id IN (1, 2))',
-        'SELECT custom_schema.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 * FROM custom_schema.comments WHERE (post_id IN (3, 4))',
-        'SELECT * FROM custom_schema.users WHERE (id IN (2, 1))',
-        'SELECT * FROM custom_schema.posts WHERE (user_id IN (1, 2))',
-        'SELECT custom_schema.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 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 custom_schema.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 custom_schema.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