rasti-db 1.3.0 → 2.0.1

data/spec/minitest_helper.rb

@@ -2,6 +2,7 @@ require 'coverage_helper'
 require 'rasti-db'
 require 'minitest/autorun'
 require 'minitest/colorin'
+require 'minitest/line/describe_track'
 require 'pry-nav'
 require 'logger'
 require 'sequel/extensions/pg_hstore'
@@ -13,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
@@ -27,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
 
@@ -38,9 +41,9 @@ 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)
-             .select_all(with_schema(:posts))
+      dataset.join(qualify(:comments), post_id: :id)
+             .where(Sequel[:comments][:user_id] => user_id)
+             .select_all(:posts)
              .distinct
     end
   end
@@ -52,8 +55,8 @@ 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)
-           .select_all(with_schema(:posts))
+           .join(qualify(:posts, data_source_name: :default), id: :post_id)
+           .select_all(:posts)
            .map { |row| Post.new row }
   end
 end
@@ -69,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
@@ -98,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
 
@@ -127,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
 
@@ -79,4 +79,12 @@ describe 'Model' do
     refute_equal User.new(id: 1, name: 'User 1').hash, User.new(id: 2, name: 'User 2').hash
   end
 
+  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
+
 end

data/spec/query_spec.rb

@@ -3,18 +3,44 @@ require 'minitest_helper'
 describe 'Query' do
 
   before do
-    1.upto(10) { |i| db[:users].insert name: "User #{i}" }
+    custom_db[:languages].insert name: 'Spanish'
 
-    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: '...'
-  end
+    1.upto(10) do |i| 
+      db[:users].insert name: "User #{i}"
+
+      db[:people].insert user_id: i, 
+                         document_number: "document_#{i}", 
+                         first_name: "Name #{i}", 
+                         last_name: "Last Name #{i}", 
+                         birth_date: Date.parse('2020-04-24')
+
+      db[:languages_people].insert language_id: 1, document_number: "document_#{i}"
+    end
 
-  let(:users_query) { Rasti::DB::Query.new Users, db[:users] }
+    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
 
-  let(:posts_query) { Rasti::DB::Query.new Posts, db[:posts] }
+    1.upto(3) { |i| db[:categories].insert name: "Category #{i}" }
+    
+    db[:comments].insert post_id: 1, user_id: 5, text: 'Comment 1'
+    db[:comments].insert post_id: 1, user_id: 7, text: 'Comment 2'
+    db[:comments].insert post_id: 2, user_id: 2, text: 'Comment 3'
+
+    db[:categories_posts].insert post_id: 1, category_id: 1
+    db[:categories_posts].insert post_id: 1, category_id: 2
+    db[:categories_posts].insert post_id: 2, category_id: 2
+    db[:categories_posts].insert post_id: 2, category_id: 3
+    db[:categories_posts].insert post_id: 3, category_id: 3
+  end
+
+  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], environment: environment }
   
-  let(:comments_query) { Rasti::DB::Query.new Comments, 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
@@ -37,6 +63,83 @@ describe 'Query' do
     users_query.primary_keys.must_equal db[:users].map { |u| u[:id] }
   end
 
+  it 'Select attributes' do
+    posts_query.select_attributes(:id, :user_id).all.must_equal db[:posts].select(:id, :user_id).map { |r| Post.new r }
+  end
+
+  it 'Exclude attributes' do
+    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
+    posts_query.exclude_attributes(:body).all_attributes.all.must_equal db[:posts].map { |r| Post.new r }
+  end
+
+  it 'Select graph attributes' do
+    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)
+
+    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(*selected_attributes.keys)
+               .select_graph_attributes(selected_attributes)
+               .all
+               .must_equal [post]
+  end
+  
+  it 'Exclude graph attributes' do
+    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)
+
+    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(*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: 'document_2').first
+
+    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)
+
+    posts_query.where(id: 1)
+               .graph('user.person')
+               .exclude_graph_attributes(user: [:name], 'user.person' => [:birth_date, :first_name, :last_name])
+               .all_graph_attributes('user.person')
+               .all
+               .must_equal [post]
+  end
+
   it 'Map' do
     users_query.map(&:name).must_equal db[:users].map(:name)
   end
@@ -66,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
   
@@ -93,21 +196,48 @@ 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 'Empty?' do
+  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
     users_query.empty?.must_equal false
     users_query.any?.must_equal true
   end
 
-  it 'Any?' do
+  it 'Empty?' do
+    db[:comments].truncate
+
     comments_query.empty?.must_equal true
     comments_query.any?.must_equal false
   end
 
   it 'To String' do
-    users_query.where(id: [1,2,3]).order(:name).to_s.must_equal '#<Rasti::DB::Query: "SELECT * FROM `users` WHERE (`id` IN (1, 2, 3)) ORDER BY `name`">'
+    users_query.where(id: [1,2,3]).order(:name).to_s.must_equal '#<Rasti::DB::Query: "SELECT `users`.* FROM `users` WHERE (`users`.`id` IN (1, 2, 3)) ORDER BY `users`.`name`">'
   end
 
   describe 'Named queries' do
@@ -126,108 +256,100 @@ describe 'Query' do
 
   describe 'Join' do
 
-    before do
-      1.upto(10) do |i| 
-        db[:people].insert user_id: i, 
-                           document_number: i, 
-                           first_name: "Name #{i}", 
-                           last_name: "Last Name #{i}", 
-                           birth_date: Time.now
-      end
-
-      1.upto(3) { |i| db[:categories].insert name: "Category #{i}" }
-      
-      db[:comments].insert post_id: 1, user_id: 5, text: 'Comment 1'
-      db[:comments].insert post_id: 1, user_id: 7, text: 'Comment 2'
-      db[:comments].insert post_id: 2, user_id: 2, text: 'Comment 3'
-
-      db[:categories_posts].insert post_id: 1, category_id: 1
-      db[:categories_posts].insert post_id: 1, category_id: 2
-      db[:categories_posts].insert post_id: 2, category_id: 2
-      db[:categories_posts].insert post_id: 2, category_id: 3
-      db[:categories_posts].insert post_id: 3, category_id: 3
-    end
-
     it 'One to Many' do
-      users_query.join(:posts).where(title: 'Sample post').all.must_equal [User.new(id: 2, name: 'User 2')]
+      users_query.join(:posts).where(Sequel[:posts][:title] => 'Sample post').all.must_equal [User.new(id: 2, name: 'User 2')]
     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(Sequel[:user][: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(Sequel[:person][: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: '...'),
+      posts_query.join(:categories).where(Sequel[:categories][:name] => 'Category 3').order(:id).all.must_equal [
+        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
 
-  end
+    it 'Excluded attributes permanents excluded when join' do
+      posts_query.join(:user)
+                 .exclude_attributes(:body)
+                 .where(Sequel[:user][:name] => 'User 4')
+                 .all
+                 .must_equal [Post.new(id: 3, title: 'Best post', user_id: 4, language_id: 1)]
 
-  describe 'NQL' do
+      posts_query.exclude_attributes(:body)
+                 .join(:user)
+                 .where(Sequel[:user][:name] => 'User 4')
+                 .all
+                 .must_equal [Post.new(id: 3, title: 'Best post', user_id: 4, language_id: 1)]
+    end
 
-    before do
-      1.upto(10) do |i| 
-        db[:people].insert user_id: i, 
-                           document_number: i, 
-                           first_name: "Name #{i}", 
-                           last_name: "Last Name #{i}", 
-                           birth_date: Time.now
+    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
 
-      1.upto(3) { |i| db[:categories].insert name: "Category #{i}" }
-      
-      db[:comments].insert post_id: 1, user_id: 5, text: 'Comment 1'
-      db[:comments].insert post_id: 1, user_id: 7, text: 'Comment 2'
-      db[:comments].insert post_id: 2, user_id: 2, text: 'Comment 3'
-
-      db[:categories_posts].insert post_id: 1, category_id: 1
-      db[:categories_posts].insert post_id: 1, category_id: 2
-      db[:categories_posts].insert post_id: 2, category_id: 2
-      db[:categories_posts].insert post_id: 2, category_id: 3
-      db[:categories_posts].insert post_id: 3, category_id: 3
+      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
+
+  describe 'NQL' do
+
     it 'Invalid expression' do
       error = proc { posts_query.nql('a + b') }.must_raise Rasti::DB::NQL::InvalidExpressionError
       error.message.must_equal 'Invalid filter expression: a + b'
     end
     
     it 'Filter to self table' do
-      people_query = Rasti::DB::Query.new People, db[:people]
-
-      people_query.nql('user_id > 7')
-                  .map(&:user_id)
-                  .sort
-                  .must_equal [8, 9, 10]
+      posts_query.nql('user_id > 1')
+                 .pluck(:user_id)
+                 .sort
+                 .must_equal [2, 4]
     end
 
     it 'Filter to join table' do
       posts_query.nql('categories.name = Category 2')
-                 .map(&:id)
+                 .pluck(:id)
                  .sort
                  .must_equal [1, 2]
     end
 
     it 'Filter to 2nd order relation' do
-      posts_query.nql('comments.user.person.document_number = 7')
-                 .map(&:id)
+      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 = document_2')
+                 .pluck(:id)
+                 .must_equal [2]
+    end
+
   end
 
 end