rasti-db 1.5.0 → 2.0.0

data/spec/minitest_helper.rb

@@ -14,10 +14,11 @@ Rasti::DB.configure do |config|
 end
 
 User     = Rasti::DB::Model[:id, :name, :posts, :comments, :person]
-Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories]
+Post     = Rasti::DB::Model[:id, :title, :body, :user_id, :user, :comments, :categories, :language_id, :language]
 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]
+Person   = Rasti::DB::Model[:document_number, :first_name, :last_name, :birth_date, :user_id, :user, :languages]
+Language = Rasti::DB::Model[:id, :name, :people]
 
 
 class Users < Rasti::DB::Collection
@@ -28,6 +29,7 @@ end
 
 class Posts < Rasti::DB::Collection
   many_to_one :user
+  many_to_one :language
   many_to_many :categories
   one_to_many :comments
 
@@ -39,8 +41,8 @@ class Posts < Rasti::DB::Collection
 
   query :commented_by do |user_id|
     chainable do
-      dataset.join(with_schema(:comments), post_id: :id)
-             .where(with_schema(:comments, :user_id) => user_id)
+      dataset.join(qualify(:comments), post_id: :id)
+             .where(Sequel[:comments][:user_id] => user_id)
              .select_all(:posts)
              .distinct
     end
@@ -53,7 +55,7 @@ class Comments < Rasti::DB::Collection
 
   def posts_commented_by(user_id)
     dataset.where(Sequel[:comments][:user_id] => user_id)
-           .join(with_schema(:posts), id: :post_id)
+           .join(qualify(:posts, data_source_name: :default), id: :post_id)
            .select_all(:posts)
            .map { |row| Post.new row }
   end
@@ -70,24 +72,39 @@ class People < Rasti::DB::Collection
   set_model Person
 
   many_to_one :user
+  many_to_many :languages
+end
+
+class Languages < Rasti::DB::Collection
+  set_data_source_name :custom
+
+  many_to_many :people, collection: People, relation_data_source_name: :default
+  one_to_many :posts
 end
 
 
 class Minitest::Spec
 
-  let(:users) { Users.new db }
+  let(:users) { Users.new environment }
 
-  let(:posts) { Posts.new db }
+  let(:posts) { Posts.new environment }
   
-  let(:comments) { Comments.new db }
+  let(:comments) { Comments.new environment }
 
-  let(:categories) { Categories.new db }
+  let(:categories) { Categories.new environment }
 
-  let(:people) { People.new db }
+  let(:people) { People.new environment }
 
-  let :db do
-    driver = (RUBY_ENGINE == 'jruby') ? 'jdbc:sqlite::memory:' : {adapter: :sqlite}
+  let(:languages) { Languages.new environment }
 
+  let(:driver) { (RUBY_ENGINE == 'jruby') ? 'jdbc:sqlite::memory:' : {adapter: :sqlite} }
+
+  let :environment do 
+    Rasti::DB::Environment.new default: Rasti::DB::DataSource.new(db),
+                               custom: Rasti::DB::DataSource.new(custom_db)
+  end
+
+  let :db do
     Sequel.connect(driver).tap do |db|
 
       db.create_table :users do
@@ -99,6 +116,7 @@ class Minitest::Spec
         primary_key :id
         String :title, null: false, unique: true
         String :body, null: false
+        Integer :language_id, null: false, index: true
         foreign_key :user_id, :users, null: false, index: true
       end
 
@@ -128,6 +146,23 @@ class Minitest::Spec
         foreign_key :user_id, :users, null: false, unique: true
       end
 
+      db.create_table :languages_people do
+        Integer :language_id, null: false, index: true
+        foreign_key :document_number, :people, type: String, null: false, index: true
+        primary_key [:language_id, :document_number]
+      end
+
+    end
+  end
+
+  let :custom_db do
+    Sequel.connect(driver).tap do |db|
+
+      db.create_table :languages do
+        primary_key :id
+        String :name, null: false, unique: true
+      end
+
     end
   end
 

data/spec/model_spec.rb

@@ -10,7 +10,7 @@ describe 'Model' do
     end
 
     it 'Invalid definition' do
-      error = proc { model = Rasti::DB::Model[:id, :name, :name] }.must_raise ArgumentError
+      error = proc { Rasti::DB::Model[:id, :name, :name] }.must_raise ArgumentError
       error.message.must_equal 'Attribute name already exists'
     end
 
@@ -82,6 +82,8 @@ describe 'Model' do
   it 'Merge' do
     user = User.new(id: 1, name: 'User 1')
     changed_user = user.merge(name: 'User 2')
+    
+    user.must_equal User.new(id: 1, name: 'User 1')
     changed_user.must_equal User.new(id: 1, name: 'User 2')
   end
 

data/spec/query_spec.rb

@@ -3,19 +3,23 @@ require 'minitest_helper'
 describe 'Query' do
 
   before do
+    custom_db[:languages].insert name: 'Spanish'
+
     1.upto(10) do |i| 
       db[:users].insert name: "User #{i}"
 
       db[:people].insert user_id: i, 
-                         document_number: i, 
+                         document_number: "document_#{i}", 
                          first_name: "Name #{i}", 
                          last_name: "Last Name #{i}", 
-                         birth_date: Time.now
+                         birth_date: Date.parse('2020-04-24')
+
+      db[:languages_people].insert language_id: 1, document_number: "document_#{i}"
     end
 
-    db[:posts].insert user_id: 2, title: 'Sample post', body: '...'
-    db[:posts].insert user_id: 1, title: 'Another post', body: '...'
-    db[:posts].insert user_id: 4, title: 'Best post', body: '...'
+    db[:posts].insert user_id: 2, title: 'Sample post', body: '...', language_id: 1
+    db[:posts].insert user_id: 1, title: 'Another post', body: '...', language_id: 1
+    db[:posts].insert user_id: 4, title: 'Best post', body: '...', language_id: 1
 
     1.upto(3) { |i| db[:categories].insert name: "Category #{i}" }
     
@@ -30,11 +34,13 @@ describe 'Query' do
     db[:categories_posts].insert post_id: 3, category_id: 3
   end
 
-  let(:users_query) { Rasti::DB::Query.new collection_class: Users, dataset: db[:users] }
+  let(:users_query) { Rasti::DB::Query.new collection_class: Users, dataset: db[:users], environment: environment }
   
-  let(:posts_query) { Rasti::DB::Query.new collection_class: Posts, dataset: db[:posts] }
+  let(:posts_query) { Rasti::DB::Query.new collection_class: Posts, dataset: db[:posts], environment: environment }
   
-  let(:comments_query) { Rasti::DB::Query.new collection_class: Comments, dataset: db[:comments] }
+  let(:comments_query) { Rasti::DB::Query.new collection_class: Comments, dataset: db[:comments], environment: environment }
+
+  let(:languages_query) { Rasti::DB::Query.new collection_class: Languages, dataset: custom_db[:languages], environment: environment }
 
   it 'Count' do
     users_query.count.must_equal 10
@@ -62,7 +68,7 @@ describe 'Query' do
   end
 
   it 'Exclude attributes' do
-    posts_query.exclude_attributes(:body).all.must_equal db[:posts].select(:id, :user_id, :title).map { |r| Post.new r }
+    posts_query.exclude_attributes(:body).all.must_equal db[:posts].select(:id, :user_id, :title, :language_id).map { |r| Post.new r }
   end
 
   it 'All attributes' do
@@ -70,35 +76,57 @@ describe 'Query' do
   end
 
   it 'Select graph attributes' do
-    person = Person.new db[:people].where(document_number: 2).select(:first_name, :last_name, :user_id).first
+    language = Language.new custom_db[:languages].where(id: 1).select(:id).first
+
+    person = Person.new db[:people].where(document_number: 'document_2').select(:document_number, :user_id).first.merge(languages: [language])
 
     user = User.new db[:users].where(id: 2).select(:id).first.merge(person: person)
 
-    post = Post.new db[:posts].where(id: 1).first.merge(user: user)
+    categories = db[:categories].where(id: [1,2]).select(:id).map { |c| Category.new c }
+
+    post = Post.new db[:posts].where(id: 1).first.merge(user: user, categories: categories)
+
+    selected_attributes = {
+      user: [:id], 
+      'user.person' => [:document_number, :user_id], 
+      'user.person.languages' => [:id],
+      categories: [:id]
+    }
 
     posts_query.where(id: 1)
-               .graph('user.person')
-               .select_graph_attributes(user: [:id], 'user.person' => [:first_name, :last_name, :user_id])
+               .graph(*selected_attributes.keys)
+               .select_graph_attributes(selected_attributes)
                .all
                .must_equal [post]
   end
   
   it 'Exclude graph attributes' do
-    person = Person.new db[:people].where(document_number: 2).select(:document_number, :last_name, :user_id).first
+    language = Language.new custom_db[:languages].where(id: 1).select(:id).first
+
+    person = Person.new db[:people].where(document_number: 'document_2').select(:document_number, :user_id).first.merge(languages: [language])
 
     user = User.new db[:users].where(id: 2).select(:id).first.merge(person: person)
 
-    post = Post.new db[:posts].where(id: 1).first.merge(user: user)
+    categories = db[:categories].where(id: [1,2]).select(:id).map { |c| Category.new c }
+
+    post = Post.new db[:posts].where(id: 1).first.merge(user: user, categories: categories)
+
+    excluded_attributes = {
+      user: [:name], 
+      'user.person' => [:first_name, :last_name, :birth_date], 
+      'user.person.languages' => [:name],
+      categories: [:name]
+    }
 
     posts_query.where(id: 1)
-               .graph('user.person')
-               .exclude_graph_attributes(user: [:name], 'user.person' => [:first_name, :birth_date])
+               .graph(*excluded_attributes.keys)
+               .exclude_graph_attributes(excluded_attributes)
                .all
                .must_equal [post]
   end
   
   it 'All graph attributes' do
-    person = Person.new db[:people].where(document_number: 2).first
+    person = Person.new db[:people].where(document_number: 'document_2').first
 
     user = User.new db[:users].where(id: 2).select(:id).first.merge(person: person)
 
@@ -141,17 +169,17 @@ describe 'Query' do
   
   it 'Order' do
     posts_query.order(:title).all.must_equal [
-      Post.new(id: 2, user_id: 1, title: 'Another post', body: '...'), 
-      Post.new(id: 3, user_id: 4, title: 'Best post', body: '...'), 
-      Post.new(id: 1, user_id: 2, title: 'Sample post', body: '...')
+      Post.new(id: 2, user_id: 1, title: 'Another post', body: '...', language_id: 1), 
+      Post.new(id: 3, user_id: 4, title: 'Best post', body: '...', language_id: 1), 
+      Post.new(id: 1, user_id: 2, title: 'Sample post', body: '...', language_id: 1)
     ]
   end
   
   it 'Reverse order' do
     posts_query.reverse_order(:title).all.must_equal [
-      Post.new(id: 1, user_id: 2, title: 'Sample post', body: '...'),
-      Post.new(id: 3, user_id: 4, title: 'Best post', body: '...'), 
-      Post.new(id: 2, user_id: 1, title: 'Another post', body: '...')
+      Post.new(id: 1, user_id: 2, title: 'Sample post', body: '...', language_id: 1),
+      Post.new(id: 3, user_id: 4, title: 'Best post', body: '...', language_id: 1), 
+      Post.new(id: 2, user_id: 1, title: 'Another post', body: '...', language_id: 1)
     ]
   end
   
@@ -168,7 +196,32 @@ describe 'Query' do
   end
 
   it 'Graph' do
-    users_query.graph(:posts).where(id: 1).first.must_equal User.new(id: 1, name: 'User 1', posts: [Post.new(id: 2, user_id: 1, title: 'Another post', body: '...')])
+    users_query.graph(:posts).where(id: 1).first.must_equal User.new(id: 1, name: 'User 1', posts: [Post.new(id: 2, user_id: 1, title: 'Another post', body: '...', language_id: 1)])
+  end
+
+  it 'Graph with multiple data sources' do
+    language = Language.new id: 1, name: 'Spanish'
+
+    person = Person.new user_id: 2,
+                        document_number: 'document_2', 
+                        first_name: 'Name 2', 
+                        last_name: 'Last Name 2', 
+                        birth_date: Date.parse('2020-04-24'),
+                        languages: [language]
+
+    user = User.new id: 2, 
+                    name: 'User 2',
+                    person: person
+
+    post = Post.new id: 1, 
+                    user_id: 2, 
+                    user: user,
+                    title: 'Sample post', 
+                    body: '...', 
+                    language_id: 1,
+                    language: language
+
+    posts_query.where(id: 1).graph(:language, 'user.person.languages').first.must_equal post
   end
 
   it 'Any?' do
@@ -208,26 +261,44 @@ describe 'Query' do
     end
 
     it 'Many to One' do
-      posts_query.join(:user).where(name: 'User 4').all.must_equal [Post.new(id: 3, user_id: 4, title: 'Best post', body: '...')]
+      posts_query.join(:user).where(name: 'User 4').all.must_equal [Post.new(id: 3, user_id: 4, title: 'Best post', body: '...', language_id: 1)]
     end
 
     it 'One to One' do
-      users_query.join(:person).where(document_number: 1).all.must_equal [User.new(id: 1, name: 'User 1')]
+      users_query.join(:person).where(document_number: 'document_1').all.must_equal [User.new(id: 1, name: 'User 1')]
     end
 
     it 'Many to Many' do
       posts_query.join(:categories).where(name: 'Category 3').order(:id).all.must_equal [
-        Post.new(id: 2, user_id: 1, title: 'Another post', body: '...'),
-        Post.new(id: 3, user_id: 4, title: 'Best post', body: '...'),
+        Post.new(id: 2, user_id: 1, title: 'Another post', body: '...', language_id: 1),
+        Post.new(id: 3, user_id: 4, title: 'Best post', body: '...', language_id: 1),
       ]
     end
 
     it 'Nested' do
       posts_query.join('categories', 'comments.user.person')
                  .where(Sequel[:categories][:name] => 'Category 2')
-                 .where(Sequel[:comments__user__person][:document_number] => 7)
+                 .where(Sequel[:comments__user__person][:document_number] => 'document_7')
                  .all
-                 .must_equal [Post.new(id: 1, user_id: 2, title: 'Sample post', body: '...')]
+                 .must_equal [Post.new(id: 1, user_id: 2, title: 'Sample post', body: '...', language_id: 1)]
+    end
+
+    describe 'Multiple data sources' do
+
+      it 'One to Many' do
+        error = proc { languages_query.join(:posts).all }.must_raise RuntimeError
+        error.message.must_equal 'Invalid join of multiple data sources: custom.languages > default.posts'
+      end
+
+      it 'Many to One' do
+        error = proc { posts_query.join(:language).all }.must_raise RuntimeError
+        error.message.must_equal 'Invalid join of multiple data sources: default.posts > custom.languages'
+      end
+
+      it 'Many to Many' do
+        error = proc { languages_query.join(:people).all }.must_raise RuntimeError
+        error.message.must_equal 'Invalid join of multiple data sources: custom.languages > default.people'
+      end
     end
 
   end
@@ -254,13 +325,13 @@ describe 'Query' do
     end
 
     it 'Filter to 2nd order relation' do
-      posts_query.nql('comments.user.person.document_number = 7')
+      posts_query.nql('comments.user.person.document_number = document_7')
                  .pluck(:id)
                  .must_equal [1]
     end
 
     it 'Filter combined' do
-      posts_query.nql('(categories.id = 1 | categories.id = 3) & comments.user.person.document_number = 2')
+      posts_query.nql('(categories.id = 1 | categories.id = 3) & comments.user.person.document_number = document_2')
                  .pluck(:id)
                  .must_equal [2]
     end

data/spec/relations_spec.rb

@@ -30,14 +30,19 @@ describe 'Relations' do
       relation.many_to_one?.must_equal false
       relation.many_to_many?.must_equal false
       relation.one_to_one?.must_equal false
+
+      relation.from_one?.must_equal true
+      relation.from_many?.must_equal false
+      relation.to_one?.must_equal false
+      relation.to_many?.must_equal true
     end
 
     it 'Graph' do
       user_id = db[:users].insert name: 'User 1'
-      1.upto(2) { |i| db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...' }
+      1.upto(2) { |i| db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...', language_id: 1 }
       rows = db[:users].all
       
-      Users.relations[:posts].fetch_graph rows, db
+      Users.relations[:posts].fetch_graph environment, rows
       
       rows[0][:posts].must_equal posts.where(user_id: user_id).all
     end
@@ -72,14 +77,19 @@ describe 'Relations' do
       relation.many_to_one?.must_equal true
       relation.many_to_many?.must_equal false
       relation.one_to_one?.must_equal false
+
+      relation.from_one?.must_equal false
+      relation.from_many?.must_equal true
+      relation.to_one?.must_equal true
+      relation.to_many?.must_equal false
     end
 
     it '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
       rows = db[:posts].all
 
-      Posts.relations[:user].fetch_graph rows, db
+      Posts.relations[:user].fetch_graph environment, rows
 
       rows[0][:user].must_equal users.first
     end
@@ -120,12 +130,17 @@ describe 'Relations' do
       relation.many_to_one?.must_equal false
       relation.many_to_many?.must_equal true
       relation.one_to_one?.must_equal false
+
+      relation.from_one?.must_equal false
+      relation.from_many?.must_equal true
+      relation.to_one?.must_equal false
+      relation.to_many?.must_equal true
     end
 
     it 'Graph' do
       user_id = db[:users].insert name: 'User 1'
 
-      1.upto(2) { |i| db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...' }
+      1.upto(2) { |i| db[:posts].insert user_id: user_id, title: "Post #{i}", body: '...', language_id: 1 }
 
       1.upto(4) { |i| db[:categories].insert name: "Category #{i}" }
 
@@ -136,7 +151,7 @@ describe 'Relations' do
 
       rows = db[:posts].all
 
-      Posts.relations[:categories].fetch_graph rows, db
+      Posts.relations[:categories].fetch_graph environment, rows
 
       rows[0][:categories].must_equal categories.where(id: [1,2]).all
       rows[1][:categories].must_equal categories.where(id: [3,4]).all
@@ -172,6 +187,11 @@ describe 'Relations' do
       relation.many_to_one?.must_equal false
       relation.many_to_many?.must_equal false
       relation.one_to_one?.must_equal true
+
+      relation.from_one?.must_equal true
+      relation.from_many?.must_equal false
+      relation.to_one?.must_equal true
+      relation.to_many?.must_equal false
     end
 
     it 'Graph' do
@@ -186,7 +206,7 @@ describe 'Relations' do
 
       rows = db[:users].all
 
-      Users.relations[:person].fetch_graph rows, db
+      Users.relations[:person].fetch_graph environment, rows
 
       2.times do |i|
         rows[i][:person].must_equal people.find("document_#{i}")